added loading script

.history/indicxnli_20220823214315.py

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,200 @@
+# 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

@@ -0,0 +1,201 @@
+# 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

@@ -0,0 +1,201 @@
+# 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

@@ -0,0 +1,201 @@
+# 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

@@ -0,0 +1,201 @@
+# 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

@@ -0,0 +1,201 @@
+# 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

@@ -0,0 +1,201 @@
+# 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

@@ -0,0 +1,201 @@
+# 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

@@ -0,0 +1,201 @@
+# 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

@@ -0,0 +1,201 @@
+# 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

@@ -0,0 +1,201 @@
+# 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

@@ -0,0 +1,202 @@
+# 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

@@ -0,0 +1,202 @@
+# 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

@@ -0,0 +1,202 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,151 @@
+# 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

@@ -0,0 +1,151 @@
+# 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_20220823221954.py

@@ -0,0 +1,151 @@
+# 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"],
+                                }