update builder script

.gitignore

@@ -0,0 +1,163 @@
+.history/
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+Foo

.history/indicxnli_20220823214315.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-# _TRAIN_DATA_URL = "https://dl.fbaipublicfiles.com/XNLI/XNLI-MT-1.0.zip"
-# _TESTVAL_DATA_URL = "https://dl.fbaipublicfiles.com/XNLI/XNLI-1.0.zip"
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823214334.py

@@ -1,200 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823220704.py

@@ -1,201 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823220708.py

@@ -1,201 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        with open()
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823220724.py

@@ -1,201 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        with open('forward/train')
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823220725.py

@@ -1,201 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        with open('forward/train', )
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823220728.py

@@ -1,201 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        with open('forward/train', 'r')
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823220732.py

@@ -1,201 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        with open('forward/train/', 'r')
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823220735.py

@@ -1,201 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        with open('forward/train/{}', 'r')
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823220738.py

@@ -1,201 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        with open(f'forward/train/{}', 'r')
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823220742.py

@@ -1,201 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        with open(f'forward/train/{language}', 'r')
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221124.py

@@ -1,201 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        with open(f'forward/train/{self.config.language}', 'r')
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221128.py

@@ -1,202 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        with open(f'forward/train/{self.config.language}', 'r') as f:
-            
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221142.py

@@ -1,202 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        with open(f'forward/train/xnli_{self.config.language}', 'r') as f:
-            
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221147.py

@@ -1,202 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        with open(f'forward/train/xnli_{self.config.language}.json', 'r') as f:
-            
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221200.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        with open(f'forward/train/xnli_{self.config.language}.json', 'r') as f:
-            
-            
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221210.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_path = f'forward/train/xnli_{self.config.language}.json', 'r') as f:
-            
-            
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221213.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_path = f'forward/train/xnli_{self.config.language}.json'
-            
-            
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221223.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_path = f'forward/train/xnli_{self.config.language}.json'
-        train_path = f'forward/train/xnli_{self.config.language}.json'
-            
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221227.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_path = f'forward/train/xnli_{self.config.language}.json'
-        dev_path = f'forward/train/xnli_{self.config.language}.json'
-            
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221233.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_path = f'forward/train/xnli_{self.config.language}.json'
-        dev_path = f'forward/train/xnli_{self.config.language}.json'
-        train_path = f'forward/train/xnli_{self.config.language}.json'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221235.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_path = f'forward/train/xnli_{self.config.language}.json'
-        dev_path = f'forward/train/xnli_{self.config.language}.json'
-        test_path = f'forward/train/xnli_{self.config.language}.json'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221240.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_path = f'forward/train/xnli_{self.config.language}.json'
-        dev_path = f'forward/train/xnli_{self.config.language}.json'
-        test_path = f'forward/test/xnli_{self.config.language}.json'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221242.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_path = f'forward/train/xnli_{self.config.language}.json'
-        dev_path = f'forward/dev/xnli_{self.config.language}.json'
-        test_path = f'forward/test/xnli_{self.config.language}.json'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221316.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_dir = f'forward/train/xnli_{self.config.language}.json'
-        dev_path = f'forward/dev/xnli_{self.config.language}.json'
-        test_path = f'forward/test/xnli_{self.config.language}.json'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221318.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_dir = f'forward/train/xnli_{self.config.language}.json'
-        dev_dir = f'forward/dev/xnli_{self.config.language}.json'
-        test_path = f'forward/test/xnli_{self.config.language}.json'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221321.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_dir = f'forward/train/xnli_{self.config.language}.json'
-        dev_dir = f'forward/dev/xnli_{self.config.language}.json'
-        test_dir = f'forward/test/xnli_{self.config.language}.json'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221324.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_dir = f'forward/train/'
-        dev_dir = f'forward/dev/xnli_{self.config.language}.json'
-        test_dir = f'forward/test/xnli_{self.config.language}.json'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221328.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_dir = f'forward/train/'
-        dev_dir = f'forward/dev/'
-        test_dir = f'forward/test/xnli_{self.config.language}.json'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221331.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_dir = f'forward/train/'
-        dev_dir = f'forward/dev/'
-        test_dir = f'forward/test/'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221333.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_dir = f'forward/train/'
-        dev_dir = f'forward/dev'
-        test_dir = f'forward/test/'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221334.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_dir = f'forward/train/'
-        dev_dir = f'forward/dev'
-        test_dir = f'forward/test'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221336.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_dir = f'forward/train'
-        dev_dir = f'forward/dev'
-        test_dir = f'forward/test'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221338.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_dir = 'forward/train'
-        dev_dir = f'forward/dev'
-        test_dir = f'forward/test'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221339.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_dir = 'forward/train'
-        dev_dir = 'forward/dev'
-        test_dir = f'forward/test'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221341.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_dir = 'forward/train'
-        dev_dir = 'forward/dev'
-        test_dir = 'forward/test'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.tsv") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221351.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_dir = 'forward/train'
-        dev_dir = 'forward/dev'
-        test_dir = 'forward/test'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"multinli.train.{lang}.json") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221357.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_dir = 'forward/train'
-        dev_dir = 'forward/dev'
-        test_dir = 'forward/test'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"xnli_{lang}.json") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI-MT",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221400.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_dir = 'forward/train'
-        dev_dir = 'forward/dev'
-        test_dir = 'forward/test'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"xnli_{lang}.json") for lang in self.config.languages
-                    ],
-                    "data_format": "XNLI",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221408.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_dir = 'forward/train'
-        dev_dir = 'forward/dev'
-        test_dir = 'forward/test'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"xnli_{lang}.json") for lang in self.config.languages
-                    ],
-                    "data_format": "IndicXNLI",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221440.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_dir = 'forward/train'
-        dev_dir = 'forward/dev'
-        test_dir = 'forward/test'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"xnli_{lang}.json") for lang in self.config.languages
-                    ],
-                    "data_format": "IndicXNLI",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    test_dir, "xnli.test.tsv")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221501.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_dir = 'forward/train'
-        dev_dir = 'forward/dev'
-        test_dir = 'forward/test'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"xnli_{lang}.json") for lang in self.config.languages
-                    ],
-                    "data_format": "IndicXNLI",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    test_dir, f"xnli_{lang}.json")], "data_format": "XNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221505.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_dir = 'forward/train'
-        dev_dir = 'forward/dev'
-        test_dir = 'forward/test'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"xnli_{lang}.json") for lang in self.config.languages
-                    ],
-                    "data_format": "IndicXNLI",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    test_dir, f"xnli_{lang}.json")], "data_format": "IndicXNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221601.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_dir = 'forward/train'
-        dev_dir = 'forward/dev'
-        test_dir = 'forward/test'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"xnli_{lang}.json") for lang in self.config.languages
-                    ],
-                    "data_format": "IndicXNLI",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    test_dir, f"xnli_{lang}.json") for lang in self.config.languages], "data_format": "IndicXNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv")], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221611.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_dir = 'forward/train'
-        dev_dir = 'forward/dev'
-        test_dir = 'forward/test'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"xnli_{lang}.json") for lang in self.config.languages
-                    ],
-                    "data_format": "IndicXNLI",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    test_dir, f"xnli_{lang}.json") for lang in self.config.languages], "data_format": "IndicXNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    testval_dir, "xnli.dev.tsv") for lang in self.config.languages], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221621.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_dir = 'forward/train'
-        dev_dir = 'forward/dev'
-        test_dir = 'forward/test'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"xnli_{lang}.json") for lang in self.config.languages
-                    ],
-                    "data_format": "IndicXNLI",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    test_dir, f"xnli_{lang}.json") for lang in self.config.languages], "data_format": "IndicXNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    test_dir, f"xnli_{lang}.json") for lang in self.config.languages], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221623.py

@@ -1,203 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_dir = 'forward/train'
-        dev_dir = 'forward/dev'
-        test_dir = 'forward/test'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"xnli_{lang}.json") for lang in self.config.languages
-                    ],
-                    "data_format": "IndicXNLI",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    test_dir, f"xnli_{lang}.json") for lang in self.config.languages], "data_format": "IndicXNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    dev_dir, f"xnli_{lang}.json") for lang in self.config.languages], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-        if self.config.language == "all_languages":
-            if data_format == "XNLI-MT":
-                with ExitStack() as stack:
-                    files = [stack.enter_context(
-                        open(filepath, encoding="utf-8")) for filepath in filepaths]
-                    readers = [csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE) for file in files]
-                    for row_idx, rows in enumerate(zip(*readers)):
-                        yield row_idx, {
-                            "premise": {lang: row["premise"] for lang, row in zip(self.config.languages, rows)},
-                            "hypothesis": {lang: row["hypo"] for lang, row in zip(self.config.languages, rows)},
-                            "label": rows[0]["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                rows_per_pair_id = collections.defaultdict(list)
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            rows_per_pair_id[row["pairID"]].append(row)
-
-                for rows in rows_per_pair_id.values():
-                    premise = {row["language"]: row["sentence1"]
-                               for row in rows}
-                    hypothesis = {row["language"]: row["sentence2"]
-                                  for row in rows}
-                    yield rows[0]["pairID"], {
-                        "premise": premise,
-                        "hypothesis": hypothesis,
-                        "label": rows[0]["gold_label"],
-                    }
-        else:
-            if data_format == "XNLI-MT":
-                for file_idx, filepath in enumerate(filepaths):
-                    file = open(filepath, encoding="utf-8")
-                    reader = csv.DictReader(
-                        file, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    for row_idx, row in enumerate(reader):
-                        key = str(file_idx) + "_" + str(row_idx)
-                        yield key, {
-                            "premise": row["premise"],
-                            "hypothesis": row["hypo"],
-                            "label": row["label"].replace("contradictory", "contradiction"),
-                        }
-            else:
-                for filepath in filepaths:
-                    with open(filepath, encoding="utf-8") as f:
-                        reader = csv.DictReader(
-                            f, delimiter="\t", quoting=csv.QUOTE_NONE)
-                        for row in reader:
-                            if row["language"] == self.config.language:
-                                yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221950.py

@@ -1,151 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_dir = 'forward/train'
-        dev_dir = 'forward/dev'
-        test_dir = 'forward/test'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"xnli_{lang}.json") for lang in self.config.languages
-                    ],
-                    "data_format": "IndicXNLI",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    test_dir, f"xnli_{lang}.json") for lang in self.config.languages], "data_format": "IndicXNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    dev_dir, f"xnli_{lang}.json") for lang in self.config.languages], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-
-       yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }

.history/indicxnli_20220823221952.py

@@ -1,151 +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
-"""XNLI: The Cross-Lingual NLI Corpus."""
-
-
-import collections
-import csv
-import os
-from contextlib import ExitStack
-
-import datasets
-
-
-_CITATION = """\
-@misc{https://doi.org/10.48550/arxiv.2204.08776,
-  doi = {10.48550/ARXIV.2204.08776},
-  
-  url = {https://arxiv.org/abs/2204.08776},
-  
-  author = {Aggarwal, Divyanshu and Gupta, Vivek and Kunchukuttan, Anoop},
-  
-  keywords = {Computation and Language (cs.CL), Artificial Intelligence (cs.AI), FOS: Computer and information sciences, FOS: Computer and information sciences},
-  
-  title = {IndicXNLI: Evaluating Multilingual Inference for Indian Languages},
-  
-  publisher = {arXiv},
-  
-  year = {2022},
-  
-  copyright = {Creative Commons Attribution 4.0 International}
-}
-}"""
-
-_DESCRIPTION = """\
-IndicXNLI is a translated version of XNLI to 11 Indic Languages. As with XNLI, 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).
-"""
-
-_LANGUAGES = (
-    'hi',
-    'bn',
-    'mr',
-    'as',
-    'ta',
-    'te',
-    'or',
-    'ml',
-    'pa',
-    'gu',
-    'kn'
-)
-
-
-class IndicxnliConfig(datasets.BuilderConfig):
-    """BuilderConfig for XNLI."""
-
-    def __init__(self, language: str, **kwargs):
-        """BuilderConfig for XNLI.
-
-        Args:
-        language: One of hi, bn, mr, as, ta, te, or, ml, pa, gu, kn
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(IndicxnliConfig, self).__init__(**kwargs)
-        self.language = language
-
-
-class Indicxnli(datasets.GeneratorBasedBuilder):
-    """XNLI: The Cross-Lingual NLI Corpus. Version 1.0."""
-
-    VERSION = datasets.Version("1.1.0", "")
-    BUILDER_CONFIG_CLASS = IndicxnliConfig
-    BUILDER_CONFIGS = [
-        IndicxnliConfig(
-            name=lang,
-            language=lang,
-            version=datasets.Version("1.1.0", ""),
-            description=f"Plain text import of IndicXNLI for the {lang} language",
-        )
-        for lang in _LANGUAGES
-    ]
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "premise": datasets.Value("string"),
-                "hypothesis": datasets.Value("string"),
-                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            # No default supervised_keys (as we have to pass both premise
-            # and hypothesis as input).
-            supervised_keys=None,
-            homepage="https://www.nyu.edu/projects/bowman/xnli/",
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        train_dir = 'forward/train'
-        dev_dir = 'forward/dev'
-        test_dir = 'forward/test'
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepaths": [
-                        os.path.join(train_dir, f"xnli_{lang}.json") for lang in self.config.languages
-                    ],
-                    "data_format": "IndicXNLI",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepaths": [os.path.join(
-                    test_dir, f"xnli_{lang}.json") for lang in self.config.languages], "data_format": "IndicXNLI"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepaths": [os.path.join(
-                    dev_dir, f"xnli_{lang}.json") for lang in self.config.languages], "data_format": "XNLI"},
-            ),
-        ]
-
-    def _generate_examples(self, data_format, filepaths):
-        """This function returns the examples in the raw (text) form."""
-        
-       yield row["pairID"], {
-                                    "premise": row["sentence1"],
-                                    "hypothesis": row["sentence2"],
-                                    "label": row["gold_label"],
-                                }