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
from datasets.tasks import QuestionAnsweringExtractive

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,
        task_templates=[
            QuestionAnsweringExtractive(
                question_column="question",
                context_column="context",
                answers_column="answers",
            )
        ],
    )


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):
        file_paths = dl_manager.download_and_extract(_URLS[self.config.name])

        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)