JGLUE.py

import json
import logging
import random
import string
import warnings
from dataclasses import dataclass
from typing import Dict, List, Literal, Optional

import datasets as ds
import pandas as pd

logger = logging.getLogger(__name__)

_JGLUE_CITATION = """\
@inproceedings{kurihara-lrec-2022-jglue,
  title={JGLUE: Japanese general language understanding evaluation},
  author={Kurihara, Kentaro and Kawahara, Daisuke and Shibata, Tomohide},
  booktitle={Proceedings of the Thirteenth Language Resources and Evaluation Conference},
  pages={2957--2966},
  year={2022},
  url={https://aclanthology.org/2022.lrec-1.317/}
}
@inproceedings{kurihara-nlp-2022-jglue,
  title={JGLUE: 日本語言語理解ベンチマーク},
  author={栗原健太郎 and 河原大輔 and 柴田知秀},
  booktitle={言語処理学会第28回年次大会},
  pages={2023--2028},
  year={2022},
  url={https://www.anlp.jp/proceedings/annual_meeting/2022/pdf_dir/E8-4.pdf},
  note={in Japanese}
}
"""

_JCOLA_CITATION = """\
@article{someya2023jcola,
  title={JCoLA: Japanese Corpus of Linguistic Acceptability}, 
  author={Taiga Someya and Yushi Sugimoto and Yohei Oseki},
  year={2023},
  eprint={2309.12676},
  archivePrefix={arXiv},
  primaryClass={cs.CL}
}
@inproceedings{someya-nlp-2022-jcola,
  title={日本語版 CoLA の構築},
  author={染谷 大河 and 大関 洋平},
  booktitle={言語処理学会第28回年次大会},
  pages={1872--1877},
  year={2022},
  url={https://www.anlp.jp/proceedings/annual_meeting/2022/pdf_dir/E7-1.pdf},
  note={in Japanese}
}
"""

_MARC_JA_CITATION = """\
@inproceedings{marc_reviews,
  title={The Multilingual Amazon Reviews Corpus},
  author={Keung, Phillip and Lu, Yichao and Szarvas, György and Smith, Noah A.},
  booktitle={Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing},
  pages={4563--4568},
  year={2020}
}
"""

_JSTS_JNLI_CITATION = """\
@inproceedings{miyazaki2016cross,
  title={Cross-lingual image caption generation},
  author={Miyazaki, Takashi and Shimizu, Nobuyuki},
  booktitle={Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)},
  pages={1780--1790},
  year={2016}
}
"""

_DESCRIPTION = """\
JGLUE, Japanese General Language Understanding Evaluation, \
is built to measure the general NLU ability in Japanese. JGLUE has been constructed \
from scratch without translation. We hope that JGLUE will facilitate NLU research in Japanese.\
"""

_JGLUE_HOMEPAGE = "https://github.com/yahoojapan/JGLUE"
_JCOLA_HOMEPAGE = "https://github.com/osekilab/JCoLA"
_MARC_JA_HOMEPAGE = "https://registry.opendata.aws/amazon-reviews-ml/"

_JGLUE_LICENSE = """\
This work is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License.\
"""

_DESCRIPTION_CONFIGS = {
    "MARC-ja": "MARC-ja is a dataset of the text classification task. This dataset is based on the Japanese portion of Multilingual Amazon Reviews Corpus (MARC) (Keung+, 2020).",
    "JCoLA": "JCoLA (Japanese Corpus of Linguistic Accept010 ability) is a novel dataset for targeted syntactic evaluations of language models in Japanese, which consists of 10,020 sentences with acceptability judgments by linguists.",
    "JSTS": "JSTS is a Japanese version of the STS (Semantic Textual Similarity) dataset. STS is a task to estimate the semantic similarity of a sentence pair.",
    "JNLI": "JNLI is a Japanese version of the NLI (Natural Language Inference) dataset. NLI is a task to recognize the inference relation that a premise sentence has to a hypothesis sentence.",
    "JSQuAD": "JSQuAD is a Japanese version of SQuAD (Rajpurkar+, 2016), one of the datasets of reading comprehension.",
    "JCommonsenseQA": "JCommonsenseQA is a Japanese version of CommonsenseQA (Talmor+, 2019), which is a multiple-choice question answering dataset that requires commonsense reasoning ability.",
}

_URLS = {
    "MARC-ja": {
        "data": "https://s3.amazonaws.com/amazon-reviews-pds/tsv/amazon_reviews_multilingual_JP_v1_00.tsv.gz",
        "filter_review_id_list": {
            "valid": "https://raw.githubusercontent.com/yahoojapan/JGLUE/main/preprocess/marc-ja/data/filter_review_id_list/valid.txt",
        },
        "label_conv_review_id_list": {
            "valid": "https://raw.githubusercontent.com/yahoojapan/JGLUE/main/preprocess/marc-ja/data/label_conv_review_id_list/valid.txt",
        },
    },
    "JCoLA": {
        "train": {
            "in_domain": {
                "json": "https://raw.githubusercontent.com/osekilab/JCoLA/main/data/jcola-v1.0/in_domain_train-v1.0.json",
            }
        },
        "valid": {
            "in_domain": {
                "json": "https://raw.githubusercontent.com/osekilab/JCoLA/main/data/jcola-v1.0/in_domain_valid-v1.0.json",
            },
            "out_of_domain": {
                "json": "https://raw.githubusercontent.com/osekilab/JCoLA/main/data/jcola-v1.0/out_of_domain_valid-v1.0.json",
                "json_annotated": "https://raw.githubusercontent.com/osekilab/JCoLA/main/data/jcola-v1.0/out_of_domain_valid_annotated-v1.0.json",
            },
        },
    },
    "JSTS": {
        "train": "https://raw.githubusercontent.com/yahoojapan/JGLUE/main/datasets/jsts-v1.1/train-v1.1.json",
        "valid": "https://raw.githubusercontent.com/yahoojapan/JGLUE/main/datasets/jsts-v1.1/valid-v1.1.json",
    },
    "JNLI": {
        "train": "https://raw.githubusercontent.com/yahoojapan/JGLUE/main/datasets/jnli-v1.1/train-v1.1.json",
        "valid": "https://raw.githubusercontent.com/yahoojapan/JGLUE/main/datasets/jnli-v1.1/valid-v1.1.json",
    },
    "JSQuAD": {
        "train": "https://raw.githubusercontent.com/yahoojapan/JGLUE/main/datasets/jsquad-v1.1/train-v1.1.json",
        "valid": "https://raw.githubusercontent.com/yahoojapan/JGLUE/main/datasets/jsquad-v1.1/valid-v1.1.json",
    },
    "JCommonsenseQA": {
        "train": "https://raw.githubusercontent.com/yahoojapan/JGLUE/main/datasets/jcommonsenseqa-v1.1/train-v1.1.json",
        "valid": "https://raw.githubusercontent.com/yahoojapan/JGLUE/main/datasets/jcommonsenseqa-v1.1/valid-v1.1.json",
    },
}


def dataset_info_jsts() -> ds.DatasetInfo:
    features = ds.Features(
        {
            "sentence_pair_id": ds.Value("string"),
            "yjcaptions_id": ds.Value("string"),
            "sentence1": ds.Value("string"),
            "sentence2": ds.Value("string"),
            "label": ds.Value("float"),
        }
    )
    return ds.DatasetInfo(
        description=_DESCRIPTION,
        citation=_JGLUE_CITATION,
        homepage=f"{_JSTS_JNLI_CITATION}\n{_JGLUE_HOMEPAGE}",
        license=_JGLUE_LICENSE,
        features=features,
    )


def dataset_info_jnli() -> ds.DatasetInfo:
    features = ds.Features(
        {
            "sentence_pair_id": ds.Value("string"),
            "yjcaptions_id": ds.Value("string"),
            "sentence1": ds.Value("string"),
            "sentence2": ds.Value("string"),
            "label": ds.ClassLabel(
                num_classes=3, names=["entailment", "contradiction", "neutral"]
            ),
        }
    )
    return ds.DatasetInfo(
        description=_DESCRIPTION,
        citation=_JGLUE_CITATION,
        homepage=f"{_JSTS_JNLI_CITATION}\n{_JGLUE_HOMEPAGE}",
        license=_JGLUE_LICENSE,
        features=features,
        supervised_keys=None,
    )


def dataset_info_jsquad() -> ds.DatasetInfo:
    features = ds.Features(
        {
            "id": ds.Value("string"),
            "title": ds.Value("string"),
            "context": ds.Value("string"),
            "question": ds.Value("string"),
            "answers": ds.Sequence(
                {"text": ds.Value("string"), "answer_start": ds.Value("int32")}
            ),
            "is_impossible": ds.Value("bool"),
        }
    )
    return ds.DatasetInfo(
        description=_DESCRIPTION,
        citation=_JGLUE_CITATION,
        homepage=_JGLUE_HOMEPAGE,
        license=_JGLUE_LICENSE,
        features=features,
        supervised_keys=None,
    )


def dataset_info_jcommonsenseqa() -> ds.DatasetInfo:
    features = ds.Features(
        {
            "q_id": ds.Value("int64"),
            "question": ds.Value("string"),
            "choice0": ds.Value("string"),
            "choice1": ds.Value("string"),
            "choice2": ds.Value("string"),
            "choice3": ds.Value("string"),
            "choice4": ds.Value("string"),
            "label": ds.ClassLabel(
                num_classes=5,
                names=["choice0", "choice1", "choice2", "choice3", "choice4"],
            ),
        }
    )
    return ds.DatasetInfo(
        description=_DESCRIPTION,
        citation=_JGLUE_CITATION,
        homepage=_JGLUE_HOMEPAGE,
        license=_JGLUE_LICENSE,
        features=features,
    )


def dataset_info_jcola() -> ds.DatasetInfo:
    features = ds.Features(
        {
            "uid": ds.Value("int64"),
            "source": ds.Value("string"),
            "label": ds.ClassLabel(
                num_classes=2,
                names=["unacceptable", "acceptable"],
            ),
            "diacritic": ds.Value("string"),
            "sentence": ds.Value("string"),
            "original": ds.Value("string"),
            "translation": ds.Value("string"),
            "gloss": ds.Value("bool"),
            "linguistic_phenomenon": {
                "argument_structure": ds.Value("bool"),
                "binding": ds.Value("bool"),
                "control_raising": ds.Value("bool"),
                "ellipsis": ds.Value("bool"),
                "filler_gap": ds.Value("bool"),
                "island_effects": ds.Value("bool"),
                "morphology": ds.Value("bool"),
                "nominal_structure": ds.Value("bool"),
                "negative_polarity_concord_items": ds.Value("bool"),
                "quantifier": ds.Value("bool"),
                "verbal_agreement": ds.Value("bool"),
                "simple": ds.Value("bool"),
            },
        }
    )
    return ds.DatasetInfo(
        description=_DESCRIPTION,
        citation=f"{_JCOLA_CITATION}\n{_JGLUE_CITATION}",
        homepage=_JCOLA_HOMEPAGE,
        features=features,
    )


def dataset_info_marc_ja() -> ds.DatasetInfo:
    features = ds.Features(
        {
            "sentence": ds.Value("string"),
            "label": ds.ClassLabel(
                num_classes=3, names=["positive", "negative", "neutral"]
            ),
            "review_id": ds.Value("string"),
        }
    )
    return ds.DatasetInfo(
        description=_DESCRIPTION,
        citation=f"{_MARC_JA_CITATION}\n{_JGLUE_CITATION}",
        homepage=_MARC_JA_HOMEPAGE,
        license=_JGLUE_LICENSE,
        features=features,
    )


@dataclass
class JGLUEConfig(ds.BuilderConfig):
    """Class for JGLUE benchmark configuration"""


@dataclass
class MarcJaConfig(JGLUEConfig):
    name: str = "MARC-ja"
    is_han_to_zen: bool = False
    max_instance_num: Optional[int] = None
    max_char_length: int = 500
    is_pos_neg: bool = True
    train_ratio: float = 0.94
    val_ratio: float = 0.03
    test_ratio: float = 0.03
    output_testset: bool = False
    filter_review_id_list_valid: bool = True
    label_conv_review_id_list_valid: bool = True

    def __post_init__(self) -> None:
        assert self.train_ratio + self.val_ratio + self.test_ratio == 1.0


JcolaDomain = Literal["in_domain", "out_of_domain"]


@dataclass
class JcolaConfig(JGLUEConfig):
    name: str = "JCoLA"
    domain: JcolaDomain = "in_domain"


def get_label(rating: int, is_pos_neg: bool = False) -> Optional[str]:
    if rating >= 4:
        return "positive"
    elif rating <= 2:
        return "negative"
    else:
        if is_pos_neg:
            return None
        else:
            return "neutral"


def is_filtered_by_ascii_rate(text: str, threshold: float = 0.9) -> bool:
    ascii_letters = set(string.printable)
    rate = sum(c in ascii_letters for c in text) / len(text)
    return rate >= threshold


def shuffle_dataframe(df: pd.DataFrame) -> pd.DataFrame:
    instances = df.to_dict(orient="records")
    random.seed(1)
    random.shuffle(instances)
    return pd.DataFrame(instances)


def get_filter_review_id_list(
    filter_review_id_list_paths: Dict[str, str],
) -> Dict[str, List[str]]:
    filter_review_id_list_valid = filter_review_id_list_paths.get("valid")
    filter_review_id_list_test = filter_review_id_list_paths.get("test")

    filter_review_id_list = {}

    if filter_review_id_list_valid is not None:
        with open(filter_review_id_list_valid, "r", encoding="utf-8") as rf:
            filter_review_id_list["valid"] = [line.rstrip() for line in rf]

    if filter_review_id_list_test is not None:
        with open(filter_review_id_list_test, "r", encoding="utf-8") as rf:
            filter_review_id_list["test"] = [line.rstrip() for line in rf]

    return filter_review_id_list


def get_label_conv_review_id_list(
    label_conv_review_id_list_paths: Dict[str, str],
) -> Dict[str, Dict[str, str]]:
    import csv

    label_conv_review_id_list_valid = label_conv_review_id_list_paths.get("valid")
    label_conv_review_id_list_test = label_conv_review_id_list_paths.get("test")

    label_conv_review_id_list: Dict[str, Dict[str, str]] = {}

    if label_conv_review_id_list_valid is not None:
        with open(label_conv_review_id_list_valid, "r", encoding="utf-8") as rf:
            label_conv_review_id_list["valid"] = {
                row[0]: row[1] for row in csv.reader(rf)
            }

    if label_conv_review_id_list_test is not None:
        with open(label_conv_review_id_list_test, "r", encoding="utf-8") as rf:
            label_conv_review_id_list["test"] = {
                row[0]: row[1] for row in csv.reader(rf)
            }

    return label_conv_review_id_list


def output_data(
    df: pd.DataFrame,
    train_ratio: float,
    val_ratio: float,
    test_ratio: float,
    output_testset: bool,
    filter_review_id_list_paths: Dict[str, str],
    label_conv_review_id_list_paths: Dict[str, str],
) -> Dict[str, pd.DataFrame]:
    instance_num = len(df)
    split_dfs: Dict[str, pd.DataFrame] = {}
    length1 = int(instance_num * train_ratio)
    split_dfs["train"] = df.iloc[:length1]

    length2 = int(instance_num * (train_ratio + val_ratio))
    split_dfs["valid"] = df.iloc[length1:length2]
    split_dfs["test"] = df.iloc[length2:]

    filter_review_id_list = get_filter_review_id_list(
        filter_review_id_list_paths=filter_review_id_list_paths,
    )
    label_conv_review_id_list = get_label_conv_review_id_list(
        label_conv_review_id_list_paths=label_conv_review_id_list_paths,
    )

    for eval_type in ("valid", "test"):
        if filter_review_id_list.get(eval_type):
            df = split_dfs[eval_type]
            df = df[~df["review_id"].isin(filter_review_id_list[eval_type])]
            split_dfs[eval_type] = df

    for eval_type in ("valid", "test"):
        if label_conv_review_id_list.get(eval_type):
            df = split_dfs[eval_type]
            df = df.assign(
                converted_label=df["review_id"].map(label_conv_review_id_list["valid"])
            )
            df = df.assign(
                label=df[["label", "converted_label"]].apply(
                    lambda xs: xs["label"]
                    if pd.isnull(xs["converted_label"])
                    else xs["converted_label"],
                    axis=1,
                )
            )
            df = df.drop(columns=["converted_label"])
            split_dfs[eval_type] = df

    return {
        "train": split_dfs["train"],
        "valid": split_dfs["valid"],
    }


def preprocess_for_marc_ja(
    config: MarcJaConfig,
    data_file_path: str,
    filter_review_id_list_paths: Dict[str, str],
    label_conv_review_id_list_paths: Dict[str, str],
) -> Dict[str, pd.DataFrame]:
    try:
        import mojimoji

        def han_to_zen(text: str) -> str:
            return mojimoji.han_to_zen(text)

    except ImportError:
        warnings.warn(
            "can't import `mojimoji`, failing back to method that do nothing. "
            "We recommend running `pip install mojimoji` to reproduce the original preprocessing.",
            UserWarning,
        )

        def han_to_zen(text: str) -> str:
            return text

    try:
        from bs4 import BeautifulSoup

        def cleanup_text(text: str) -> str:
            return BeautifulSoup(text, "html.parser").get_text()

    except ImportError:
        warnings.warn(
            "can't import `beautifulsoup4`, failing back to method that do nothing."
            "We recommend running `pip install beautifulsoup4` to reproduce the original preprocessing.",
            UserWarning,
        )

        def cleanup_text(text: str) -> str:
            return text

    from tqdm import tqdm

    df = pd.read_csv(data_file_path, delimiter="\t")
    df = df[["review_body", "star_rating", "review_id"]]

    # rename columns
    df = df.rename(columns={"review_body": "text", "star_rating": "rating"})

    # convert the rating to label
    tqdm.pandas(dynamic_ncols=True, desc="Convert the rating to the label")
    df = df.assign(
        label=df["rating"].progress_apply(
            lambda rating: get_label(rating, config.is_pos_neg)
        )
    )

    # remove rows where the label is None
    df = df[~df["label"].isnull()]

    # remove html tags from the text
    tqdm.pandas(dynamic_ncols=True, desc="Remove html tags from the text")
    df = df.assign(text=df["text"].progress_apply(cleanup_text))

    # filter by ascii rate
    tqdm.pandas(dynamic_ncols=True, desc="Filter by ascii rate")
    df = df[~df["text"].progress_apply(is_filtered_by_ascii_rate)]

    if config.max_char_length is not None:
        df = df[df["text"].str.len() <= config.max_char_length]

    if config.is_han_to_zen:
        df = df.assign(text=df["text"].apply(han_to_zen))

    df = df[["text", "label", "review_id"]]
    df = df.rename(columns={"text": "sentence"})

    # shuffle dataset
    df = shuffle_dataframe(df)

    split_dfs = output_data(
        df=df,
        train_ratio=config.train_ratio,
        val_ratio=config.val_ratio,
        test_ratio=config.test_ratio,
        output_testset=config.output_testset,
        filter_review_id_list_paths=filter_review_id_list_paths,
        label_conv_review_id_list_paths=label_conv_review_id_list_paths,
    )
    return split_dfs


class JGLUE(ds.GeneratorBasedBuilder):
    JGLUE_VERSION = ds.Version("1.1.0")
    JCOLA_VERSION = ds.Version("1.0.0")

    BUILDER_CONFIG_CLASS = JGLUEConfig
    BUILDER_CONFIGS = [
        MarcJaConfig(
            name="MARC-ja",
            version=JGLUE_VERSION,
            description=_DESCRIPTION_CONFIGS["MARC-ja"],
        ),
        JcolaConfig(
            name="JCoLA",
            version=JCOLA_VERSION,
            description=_DESCRIPTION_CONFIGS["JCoLA"],
        ),
        JGLUEConfig(
            name="JSTS",
            version=JGLUE_VERSION,
            description=_DESCRIPTION_CONFIGS["JSTS"],
        ),
        JGLUEConfig(
            name="JNLI",
            version=JGLUE_VERSION,
            description=_DESCRIPTION_CONFIGS["JNLI"],
        ),
        JGLUEConfig(
            name="JSQuAD",
            version=JGLUE_VERSION,
            description=_DESCRIPTION_CONFIGS["JSQuAD"],
        ),
        JGLUEConfig(
            name="JCommonsenseQA",
            version=JGLUE_VERSION,
            description=_DESCRIPTION_CONFIGS["JCommonsenseQA"],
        ),
    ]

    def _info(self) -> ds.DatasetInfo:
        if self.config.name == "JSTS":
            return dataset_info_jsts()
        elif self.config.name == "JNLI":
            return dataset_info_jnli()
        elif self.config.name == "JSQuAD":
            return dataset_info_jsquad()
        elif self.config.name == "JCommonsenseQA":
            return dataset_info_jcommonsenseqa()
        elif self.config.name == "JCoLA":
            return dataset_info_jcola()
        elif self.config.name == "MARC-ja":
            return dataset_info_marc_ja()
        else:
            raise ValueError(f"Invalid config name: {self.config.name}")

    def __split_generators_marc_ja(self, dl_manager: ds.DownloadManager):
        try:
            file_paths = dl_manager.download_and_extract(_URLS[self.config.name])
        except FileNotFoundError as err:
            logger.warning(err)
            # An error occurs because the file cannot be downloaded from _URLS[MARC-ja]['data'].
            # So, remove the 'data' key and try to download again.
            urls = _URLS[self.config.name]
            urls.pop("data")  # type: ignore[attr-defined]
            file_paths = dl_manager.download_and_extract(urls)

        filter_review_id_list = file_paths["filter_review_id_list"]
        label_conv_review_id_list = file_paths["label_conv_review_id_list"]

        try:
            split_dfs = preprocess_for_marc_ja(
                config=self.config,
                data_file_path=file_paths["data"],
                filter_review_id_list_paths=filter_review_id_list,
                label_conv_review_id_list_paths=label_conv_review_id_list,
            )
        except KeyError as err:
            from urllib.parse import urljoin

            logger.warning(err)

            base_url = "https://huggingface.co/datasets/shunk031/JGLUE/resolve/refs%2Fconvert%2Fparquet/MARC-ja/"
            marcja_parquet_urls = {
                "train": urljoin(base_url, "jglue-train.parquet"),
                "valid": urljoin(base_url, "jglue-validation.parquet"),
            }
            file_paths = dl_manager.download_and_extract(marcja_parquet_urls)
            split_dfs = {k: pd.read_parquet(v) for k, v in file_paths.items()}

        return [
            ds.SplitGenerator(
                name=ds.Split.TRAIN,
                gen_kwargs={"split_df": split_dfs["train"]},
            ),
            ds.SplitGenerator(
                name=ds.Split.VALIDATION,
                gen_kwargs={"split_df": split_dfs["valid"]},
            ),
        ]

    def __split_generators_jcola(self, dl_manager: ds.DownloadManager):
        file_paths = dl_manager.download_and_extract(_URLS[self.config.name])

        return [
            ds.SplitGenerator(
                name=ds.Split.TRAIN,
                gen_kwargs={"file_path": file_paths["train"]["in_domain"]["json"]},
            ),
            ds.SplitGenerator(
                name=ds.Split.VALIDATION,
                gen_kwargs={"file_path": file_paths["valid"]["in_domain"]["json"]},
            ),
            ds.SplitGenerator(
                name=ds.NamedSplit("validation_out_of_domain"),
                gen_kwargs={"file_path": file_paths["valid"]["out_of_domain"]["json"]},
            ),
            ds.SplitGenerator(
                name=ds.NamedSplit("validation_out_of_domain_annotated"),
                gen_kwargs={
                    "file_path": file_paths["valid"]["out_of_domain"]["json_annotated"]
                },
            ),
        ]

    def __split_generators(self, dl_manager: ds.DownloadManager):
        file_paths = dl_manager.download_and_extract(_URLS[self.config.name])

        return [
            ds.SplitGenerator(
                name=ds.Split.TRAIN,
                gen_kwargs={"file_path": file_paths["train"]},
            ),
            ds.SplitGenerator(
                name=ds.Split.VALIDATION,
                gen_kwargs={"file_path": file_paths["valid"]},
            ),
        ]

    def _split_generators(self, dl_manager: ds.DownloadManager):
        if self.config.name == "MARC-ja":
            return self.__split_generators_marc_ja(dl_manager)
        elif self.config.name == "JCoLA":
            return self.__split_generators_jcola(dl_manager)
        else:
            return self.__split_generators(dl_manager)

    def __generate_examples_marc_ja(self, split_df: Optional[pd.DataFrame] = None):
        if split_df is None:
            raise ValueError(f"Invalid preprocessing for {self.config.name}")

        instances = split_df.to_dict(orient="records")
        for i, data_dict in enumerate(instances):
            yield i, data_dict

    def __generate_examples_jcola(self, file_path: Optional[str] = None):
        if file_path is None:
            raise ValueError(f"Invalid argument for {self.config.name}")

        def convert_label(json_dict):
            label_int = json_dict["label"]
            label_str = "unacceptable" if label_int == 0 else "acceptable"
            json_dict["label"] = label_str
            return json_dict

        def convert_addntional_info(json_dict):
            json_dict["translation"] = json_dict.get("translation")
            json_dict["gloss"] = json_dict.get("gloss")
            return json_dict

        def convert_phenomenon(json_dict):
            argument_structure = json_dict.get("Arg. Str.")

            def json_pop(key):
                return json_dict.pop(key) if argument_structure is not None else None

            json_dict["linguistic_phenomenon"] = {
                "argument_structure": json_pop("Arg. Str."),
                "binding": json_pop("binding"),
                "control_raising": json_pop("control/raising"),
                "ellipsis": json_pop("ellipsis"),
                "filler_gap": json_pop("filler-gap"),
                "island_effects": json_pop("island effects"),
                "morphology": json_pop("morphology"),
                "nominal_structure": json_pop("nominal structure"),
                "negative_polarity_concord_items": json_pop("NPI/NCI"),
                "quantifier": json_pop("quantifier"),
                "verbal_agreement": json_pop("verbal agr."),
                "simple": json_pop("simple"),
            }
            return json_dict

        with open(file_path, "r", encoding="utf-8") as rf:
            for i, line in enumerate(rf):
                json_dict = json.loads(line)

                example = convert_label(json_dict)
                example = convert_addntional_info(example)
                example = convert_phenomenon(example)

                yield i, example

    def __generate_examples_jsquad(self, file_path: Optional[str] = None):
        if file_path is None:
            raise ValueError(f"Invalid argument for {self.config.name}")

        with open(file_path, "r", encoding="utf-8") as rf:
            json_data = json.load(rf)

        for json_dict in json_data["data"]:
            title = json_dict["title"]
            paragraphs = json_dict["paragraphs"]

            for paragraph in paragraphs:
                context = paragraph["context"]
                questions = paragraph["qas"]

                for question_dict in questions:
                    q_id = question_dict["id"]
                    question = question_dict["question"]
                    answers = question_dict["answers"]
                    is_impossible = question_dict["is_impossible"]

                    example_dict = {
                        "id": q_id,
                        "title": title,
                        "context": context,
                        "question": question,
                        "answers": answers,
                        "is_impossible": is_impossible,
                    }

                    yield q_id, example_dict

    def __generate_examples_jcommonsenseqa(self, file_path: Optional[str] = None):
        if file_path is None:
            raise ValueError(f"Invalid argument for {self.config.name}")

        with open(file_path, "r", encoding="utf-8") as rf:
            for i, line in enumerate(rf):
                json_dict = json.loads(line)
                json_dict["label"] = f"choice{json_dict['label']}"
                yield i, json_dict

    def __generate_examples(self, file_path: Optional[str] = None):
        if file_path is None:
            raise ValueError(f"Invalid argument for {self.config.name}")

        with open(file_path, "r", encoding="utf-8") as rf:
            for i, line in enumerate(rf):
                json_dict = json.loads(line)
                yield i, json_dict

    def _generate_examples(
        self,
        file_path: Optional[str] = None,
        split_df: Optional[pd.DataFrame] = None,
    ):
        if self.config.name == "MARC-ja":
            yield from self.__generate_examples_marc_ja(split_df)

        elif self.config.name == "JCoLA":
            yield from self.__generate_examples_jcola(file_path)

        elif self.config.name == "JSQuAD":
            yield from self.__generate_examples_jsquad(file_path)

        elif self.config.name == "JCommonsenseQA":
            yield from self.__generate_examples_jcommonsenseqa(file_path)

        else:
            yield from self.__generate_examples(file_path)