Datasets:
Languages:
Japanese
Multilinguality:
monolingual
Annotations Creators:
crowdsourced
Source Datasets:
original
ArXiv:
License:
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, | |
) | |
class JGLUEConfig(ds.BuilderConfig): | |
"""Class for JGLUE benchmark configuration""" | |
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"] | |
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) | |