indicxnli.py

# 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
import json
# 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
        self.languages = _LANGUAGES


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."""

        file_path = ""
        for path in filepaths:
            if path[-7:-5] == self.config.language:
                file_path = path
                break

        with open(file_path, "r") as f:
            data = json.load(f)
            data = data[data.keys()[0]]

        for idx, row in enumerate(data):
            yield idx, {
                "premise": row["sentence1"],
                "hypothesis": row["sentence2"],
                "label": row["gold_label"],
            }