Merge pull request #1 from shunk031/initialize

.github/workflows/ci.yaml

@@ -0,0 +1,45 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+    paths-ignore:
+      - 'README.md'
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['3.8', '3.9', '3.10']
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v2
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          pip install -U pip setuptools wheel poetry
+          poetry install
+      - name: Format
+        run: |
+          poetry run black --check .
+      - name: Lint
+        run: |
+          poetry run flake8 . --ignore=E501,W503,E203
+      - name: Type check
+        run: |
+          poetry run mypy . \
+            --ignore-missing-imports \
+            --no-strict-optional \
+            --no-site-packages \
+            --cache-dir=/dev/null
+            
+      - name: Run tests
+        run: |
+          poetry run pytest --color=yes -rf

.github/workflows/push_to_hub.yaml

@@ -0,0 +1,26 @@
+name: Sync to Hugging Face Hub
+
+on:
+  workflow_run:
+    workflows:
+      - CI
+    branches:
+      - main
+    types: 
+      - completed
+
+jobs:
+  push_to_hub:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+        
+      - name: Push to Huggingface hub
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+          HF_USERNAME: ${{ secrets.HF_USERNAME }}
+        run: |
+          git fetch --unshallow
+          git push --force https://${HF_USERNAME}:${HF_TOKEN}@huggingface.co/datasets/${HF_USERNAME}/JGLUE main

.gitignore

@@ -0,0 +1,173 @@
+# Created by https://www.toptal.com/developers/gitignore/api/python
+# Edit at https://www.toptal.com/developers/gitignore?templates=python
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# End of https://www.toptal.com/developers/gitignore/api/python

JGLUE.py

@@ -0,0 +1,494 @@
+import json
+import random
+import string
+from typing import Dict, List, Optional, Union
+
+import datasets as ds
+import pandas as pd
+
+_CITATION = """\
+@inproceedings{kurihara-etal-2022-jglue,
+    title = "{JGLUE}: {J}apanese General Language Understanding Evaluation",
+    author = "Kurihara, Kentaro  and
+      Kawahara, Daisuke  and
+      Shibata, Tomohide",
+    booktitle = "Proceedings of the Thirteenth Language Resources and Evaluation Conference",
+    month = jun,
+    year = "2022",
+    address = "Marseille, France",
+    publisher = "European Language Resources Association",
+    url = "https://aclanthology.org/2022.lrec-1.317",
+    pages = "2957--2966",
+    abstract = "To develop high-performance natural language understanding (NLU) models, it is necessary to have a benchmark to evaluate and analyze NLU ability from various perspectives. While the English NLU benchmark, GLUE, has been the forerunner, benchmarks are now being released for languages other than English, such as CLUE for Chinese and FLUE for French; but there is no such benchmark for Japanese. We build a Japanese NLU benchmark, JGLUE, from scratch without translation to measure the general NLU ability in Japanese. We hope that JGLUE will facilitate NLU research in Japanese.",
+}
+
+@InProceedings{Kurihara_nlp2022,
+  author = 	"栗原健太郎 and 河原大輔 and 柴田知秀",
+  title = 	"JGLUE: 日本語言語理解ベンチマーク",
+  booktitle = 	"言語処理学会第28回年次大会",
+  year =	"2022",
+  url = "https://www.anlp.jp/proceedings/annual_meeting/2022/pdf_dir/E8-4.pdf"
+  note= "in Japanese"
+}
+"""
+
+_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.
+"""
+
+_HOMEPAGE = "https://github.com/yahoojapan/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).",
+    "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"
+        },
+    },
+    "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 features_jsts() -> ds.Features:
+    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 features
+
+
+def features_jnli() -> ds.Features:
+    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 features
+
+
+def features_jsquad() -> ds.Features:
+    title = ds.Value("string")
+    answers = ds.Sequence(
+        {"text": ds.Value("string"), "answer_start": ds.Value("int64")}
+    )
+    qas = ds.Sequence(
+        {
+            "question": ds.Value("string"),
+            "id": ds.Value("string"),
+            "answers": answers,
+            "is_impossible": ds.Value("bool"),
+        }
+    )
+    paragraphs = ds.Sequence({"qas": qas, "context": ds.Value("string")})
+    features = ds.Features(
+        {"data": ds.Sequence({"title": title, "paragraphs": paragraphs})}
+    )
+    return features
+
+
+def features_jcommonsenseqa() -> ds.Features:
+    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.Value("int8"),
+        }
+    )
+    return features
+
+
+def features_marc_ja() -> ds.Features:
+    features = ds.Features(
+        {
+            "sentence": ds.Value("string"),
+            "label": ds.ClassLabel(
+                num_classes=3, names=["positive", "negative", "neutral"]
+            ),
+            "review_id": ds.Value("string"),
+        }
+    )
+    return features
+
+
+class MarcJaConfig(ds.BuilderConfig):
+    def __init__(
+        self,
+        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,
+        version: Optional[Union[ds.utils.Version, str]] = ds.utils.Version("0.0.0"),
+        data_dir: Optional[str] = None,
+        data_files: Optional[ds.data_files.DataFilesDict] = None,
+        description: Optional[str] = None,
+    ) -> None:
+        super().__init__(
+            name=name,
+            version=version,
+            data_dir=data_dir,
+            data_files=data_files,
+            description=description,
+        )
+        assert train_ratio + val_ratio + test_ratio == 1.0
+
+        self.train_ratio = train_ratio
+        self.val_ratio = val_ratio
+        self.test_ratio = test_ratio
+
+        self.is_han_to_zen = is_han_to_zen
+        self.max_instance_num = max_instance_num
+        self.max_char_length = max_char_length
+        self.is_pos_neg = is_pos_neg
+        self.output_testset = output_testset
+
+        self.filter_review_id_list_valid = filter_review_id_list_valid
+        self.label_conv_review_id_list_valid = label_conv_review_id_list_valid
+
+
+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") 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") 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") 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") 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]:
+    import mojimoji
+    from bs4 import BeautifulSoup
+    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(
+            lambda text: BeautifulSoup(text, "html.parser").get_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(mojimoji.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):
+    VERSION = ds.Version("1.1.0")
+    BUILDER_CONFIGS = [
+        MarcJaConfig(
+            name="MARC-ja",
+            version=VERSION,
+            description=_DESCRIPTION_CONFIGS["MARC-ja"],
+        ),
+        ds.BuilderConfig(
+            name="JSTS",
+            version=VERSION,
+            description=_DESCRIPTION_CONFIGS["JSTS"],
+        ),
+        ds.BuilderConfig(
+            name="JNLI",
+            version=VERSION,
+            description=_DESCRIPTION_CONFIGS["JNLI"],
+        ),
+        ds.BuilderConfig(
+            name="JSQuAD",
+            version=VERSION,
+            description=_DESCRIPTION_CONFIGS["JSQuAD"],
+        ),
+        ds.BuilderConfig(
+            name="JCommonsenseQA",
+            version=VERSION,
+            description=_DESCRIPTION_CONFIGS["JCommonsenseQA"],
+        ),
+    ]
+
+    def _info(self) -> ds.DatasetInfo:
+        if self.config.name == "JSTS":
+            features = features_jsts()
+        elif self.config.name == "JNLI":
+            features = features_jnli()
+        elif self.config.name == "JSQuAD":
+            features = features_jsquad()
+        elif self.config.name == "JCommonsenseQA":
+            features = features_jcommonsenseqa()
+        elif self.config.name == "MARC-ja":
+            features = features_marc_ja()
+        else:
+            raise ValueError(f"Invalid config name: {self.config.name}")
+
+        return ds.DatasetInfo(
+            description=_DESCRIPTION,
+            citation=_CITATION,
+            homepage=_HOMEPAGE,
+            license=_LICENSE,
+            features=features,
+        )
+
+    def _split_generators(self, dl_manager: ds.DownloadManager):
+        file_paths = dl_manager.download_and_extract(_URLS[self.config.name])
+
+        if self.config.name == "MARC-ja":
+            filter_review_id_list = file_paths["filter_review_id_list"]
+            label_conv_review_id_list = file_paths["label_conv_review_id_list"]
+
+            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,
+            )
+            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"]},
+                ),
+            ]
+        else:
+            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 _generate_examples(
+        self,
+        file_path: Optional[str] = None,
+        split_df: Optional[pd.DataFrame] = None,
+    ):
+        if self.config.name == "MARC-ja":
+            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
+
+        else:
+            if file_path is None:
+                raise ValueError(f"Invalid argument for {self.config.name}")
+
+            with open(file_path, "r") as rf:
+                for i, line in enumerate(rf):
+                    json_dict = json.loads(line)
+                    yield i, json_dict

README.md

@@ -0,0 +1,541 @@
+---
+annotations_creators:
+- crowdsourced
+language:
+- ja
+language_creators:
+- crowdsourced
+- found
+license:
+- cc-by-4.0
+multilinguality:
+- monolingual
+pretty_name: JGLUE
+size_categories: []
+source_datasets:
+- original
+tags:
+- MARC
+- STS
+- NLI
+- SQuAD
+- CommonsenseQA
+task_categories:
+- multiple-choice
+- question-answering
+- sentence-similarity
+- text-classification
+task_ids:
+- multiple-choice-qa
+- open-domain-qa
+- multi-class-classification
+- sentiment-classification
+---
+
+# Dataset Card for JGLUE
+
+[![CI](https://github.com/shunk031/huggingface-datasets_JGLUE/actions/workflows/ci.yaml/badge.svg)](https://github.com/shunk031/huggingface-datasets_JGLUE/actions/workflows/ci.yaml)
+[![ACL2020 2020.acl-main.419](https://img.shields.io/badge/LREC2022-2022.lrec--1.317-red)](https://aclanthology.org/2022.lrec-1.317)
+
+## Table of Contents
+- [Table of Contents](#table-of-contents)
+- [Dataset Description](#dataset-description)
+  - [Dataset Summary](#dataset-summary)
+  - [Supported Tasks and Leaderboards](#supported-tasks-and-leaderboards)
+  - [Languages](#languages)
+- [Dataset Structure](#dataset-structure)
+  - [Data Instances](#data-instances)
+  - [Data Fields](#data-fields)
+  - [Data Splits](#data-splits)
+- [Dataset Creation](#dataset-creation)
+  - [Curation Rationale](#curation-rationale)
+  - [Source Data](#source-data)
+  - [Annotations](#annotations)
+  - [Personal and Sensitive Information](#personal-and-sensitive-information)
+- [Considerations for Using the Data](#considerations-for-using-the-data)
+  - [Social Impact of Dataset](#social-impact-of-dataset)
+  - [Discussion of Biases](#discussion-of-biases)
+  - [Other Known Limitations](#other-known-limitations)
+- [Additional Information](#additional-information)
+  - [Dataset Curators](#dataset-curators)
+  - [Licensing Information](#licensing-information)
+  - [Citation Information](#citation-information)
+  - [Contributions](#contributions)
+
+## Dataset Description
+
+- **Homepage:** https://github.com/yahoojapan/JGLUE
+- **Repository:** https://github.com/shunk031/huggingface-datasets_JGLUE
+
+### Dataset Summary
+
+From [the official README.md](https://github.com/yahoojapan/JGLUE#jglue-japanese-general-language-understanding-evaluation):
+
+> 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 has been constructed by a joint research project of Yahoo Japan Corporation and Kawahara Lab at Waseda University.
+
+### Supported Tasks and Leaderboards
+
+From [the official README.md](https://github.com/yahoojapan/JGLUE#tasksdatasets):
+
+> JGLUE consists of the tasks of text classification, sentence pair classification, and QA. Each task consists of multiple datasets. 
+
+#### Supported Tasks
+
+##### MARC-ja
+
+From [the official README.md](https://github.com/yahoojapan/JGLUE#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)](https://docs.opendata.aws/amazon-reviews-ml/readme.html) ([Keung+, 2020](https://aclanthology.org/2020.emnlp-main.369/)).
+
+##### JSTS
+
+From [the official README.md](https://github.com/yahoojapan/JGLUE#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. The sentences in JSTS and JNLI (described below) are extracted from the Japanese version of the MS COCO Caption Dataset, [the YJ Captions Dataset](https://github.com/yahoojapan/YJCaptions) ([Miyazaki and Shimizu, 2016](https://aclanthology.org/P16-1168/)).
+
+##### JNLI
+
+From [the official README.md](https://github.com/yahoojapan/JGLUE#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. The inference relations are entailment, contradiction, and neutral.
+
+##### JSQuAD
+
+From [the official README.md](https://github.com/yahoojapan/JGLUE#jsquad):
+
+> JSQuAD is a Japanese version of [SQuAD](https://rajpurkar.github.io/SQuAD-explorer/) ([Rajpurkar+, 2018](https://aclanthology.org/P18-2124/)), one of the datasets of reading comprehension. Each instance in the dataset consists of a question regarding a given context (Wikipedia article) and its answer. JSQuAD is based on SQuAD 1.1 (there are no unanswerable questions). We used [the Japanese Wikipedia dump](https://dumps.wikimedia.org/jawiki/) as of 20211101.
+
+##### JCommonsenseQA
+
+From [the official README.md](https://github.com/yahoojapan/JGLUE#jcommonsenseqa):
+
+> JCommonsenseQA is a Japanese version of [CommonsenseQA](https://www.tau-nlp.org/commonsenseqa) ([Talmor+, 2019](https://aclanthology.org/N19-1421/)), which is a multiple-choice question answering dataset that requires commonsense reasoning ability. It is built using crowdsourcing with seeds extracted from the knowledge base [ConceptNet](https://conceptnet.io/).
+
+#### Leaderboard
+
+From [the official README.md](https://github.com/yahoojapan/JGLUE#leaderboard):
+
+> A leaderboard will be made public soon. The test set will be released at that time.
+
+### Languages
+
+The language data in JGLUE is in Japanese ([BCP-47 ja-JP](https://www.rfc-editor.org/info/bcp47)).
+
+## Dataset Structure
+
+### Data Instances
+
+When loading a specific configuration, users has to append a version dependent suffix:
+
+#### MARC-ja
+
+```python
+from datasets import load_dataset
+
+dataset = load_dataset("shunk031/JGLUE", name="MARC-ja")
+
+print(dataset)
+# DatasetDict({
+#     train: Dataset({
+#         features: ['sentence', 'label', 'review_id'],
+#         num_rows: 187528
+#     })
+#     validation: Dataset({
+#         features: ['sentence', 'label', 'review_id'],
+#         num_rows: 5654
+#     })
+# })
+```
+
+#### JSTS
+
+```python
+from datasets import load_dataset
+
+dataset = load_dataset("shunk031/JGLUE", name="JSTS")
+
+print(dataset)
+# DatasetDict({
+#     train: Dataset({
+#         features: ['sentence_pair_id', 'yjcaptions_id', 'sentence1', 'sentence2', 'label'],
+#         num_rows: 12451
+#     })
+#     validation: Dataset({
+#         features: ['sentence_pair_id', 'yjcaptions_id', 'sentence1', 'sentence2', 'label'],
+#         num_rows: 1457
+#     })
+# })
+```
+
+An example of the JSTS dataset looks as follows:
+
+```json
+{
+  "sentence_pair_id": "691",
+  "yjcaptions_id": "127202-129817-129818",
+  "sentence1": "街中の道路を大きなバスが走っています。 (A big bus is running on the road in the city.)", 
+  "sentence2": "道路を大きなバスが走っています。 (There is a big bus running on the road.)", 
+  "label": 4.4
+}
+```
+
+#### JNLI
+
+```python
+from datasets import load_dataset
+
+dataset = load_dataset("shunk031/JGLUE", name="JNLI")
+
+print(dataset)
+# DatasetDict({
+#     train: Dataset({
+#         features: ['sentence_pair_id', 'yjcaptions_id', 'sentence1', 'sentence2', 'label'],
+#         num_rows: 20073
+#     })
+#     validation: Dataset({
+#         features: ['sentence_pair_id', 'yjcaptions_id', 'sentence1', 'sentence2', 'label'],
+#         num_rows: 2434
+#     })
+# })
+```
+
+An example of the JNLI dataset looks as follows:
+
+```json
+{
+  "sentence_pair_id": "1157",
+  "yjcaptions_id": "127202-129817-129818",
+  "sentence1": "街中の道路を大きなバスが走っています。 (A big bus is running on the road in the city.)", 
+  "sentence2": "道路を大きなバスが走っています。 (There is a big bus running on the road.)", 
+  "label": "entailment"
+}
+```
+
+#### JSQuAD
+
+```python
+from datasets import load_dataset
+
+dataset = load_dataset("shunk031/JGLUE", name="JSQuAD")
+
+print(dataset)
+# DatasetDict({
+#     train: Dataset({
+#         features: ['data'],
+#         num_rows: 1
+#     })
+#     validation: Dataset({
+#         features: ['data'],
+#         num_rows: 1
+#     })
+# })
+```
+
+An example of the JSQuAD looks as follows:
+
+```json
+{
+  "title": "東海道新幹線 (Tokaido Shinkansen)",
+  "paragraphs": [
+    {
+      "qas": [
+        {
+          "question": "2020 年（令和 2 年）3 月現在、東京駅 - 新大阪駅間の最高速度はどのくらいか。 (What is the maximum speed between Tokyo Station and Shin-Osaka Station as of March 2020?)",
+          "id": "a1531320p0q0",
+          "answers": [
+            {
+              "text": "285 km/h",
+              "answer_start": 182
+            }
+          ],
+          "is_impossible": false
+        },
+        {
+          .. 
+        }
+      ],
+      "context": "東海道新幹線 [SEP] 1987 年（昭和 62 年）4 月 1 日の国鉄分割民営化により、JR 東海が運営を継承した。西日本旅客鉄道（JR 西日本）が継承した山陽新幹線とは相互乗り入れが行われており、東海道新幹線区間のみで運転される列車にも JR 西日本所有の車両が使用されることがある。2020 年（令和 2 年）3 月現在、東京駅 - 新大阪駅間の所要時間は最速 2 時間 21 分、最高速度 285 km/h で運行されている。"
+    }
+  ]
+}
+```
+
+#### JCommonsenseQA
+
+```python
+from datasets import load_dataset
+
+dataset = load_dataset("shunk031/JGLUE", name="JCommonsenseQA")
+
+print(dataset)
+# DatasetDict({
+#     train: Dataset({
+#         features: ['q_id', 'question', 'choice0', 'choice1', 'choice2', 'choice3', 'choice4', 'label'],
+#         num_rows: 8939
+#     })
+#     validation: Dataset({
+#         features: ['q_id', 'question', 'choice0', 'choice1', 'choice2', 'choice3', 'choice4', 'label'],
+#         num_rows: 1119
+#     })
+# })
+```
+
+An example of the JCommonsenseQA looks as follows:
+
+```json
+{
+  "q_id": 3016,
+  "question": "会社の最高責任者を何というか？ (What do you call the chief executive officer of a company?)",
+  "choice0": "社長 (president)",
+  "choice1": "教師 (teacher)",
+  "choice2": "部長 (manager)",
+  "choice3": "バイト (part-time worker)",
+  "choice4": "部下 (subordinate)",
+  "label": 0
+}
+```
+
+### Data Fields
+
+#### MARC-ja
+
+- `sentence_pair_id`: ID of the sentence pair
+- `yjcaptions_id`: sentence ids in yjcaptions (explained below)
+- `sentence1`: first sentence
+- `sentence2`: second sentence
+- `label`: sentence similarity: 5 (equivalent meaning) - 0 (completely different meaning)
+
+##### Explanation for `yjcaptions_id`
+
+From [the official README.md](https://github.com/yahoojapan/JGLUE#explanation-for-yjcaptions_id), there are the following two cases:
+
+1. sentence pairs in one image: `(image id)-(sentence1 id)-(sentence2 id)`
+    - e.g., 723-844-847
+    - a sentence id starting with "g" means a sentence generated by a crowdworker (e.g., 69501-75698-g103): only for JNLI
+2. sentence pairs in two images: `(image id of sentence1)_(image id of sentence2)-(sentence1 id)-(sentence2 id)`
+    - e.g., 91337_217583-96105-91680
+
+#### JNLI
+
+- `sentence_pair_id`: ID of the sentence pair
+- `yjcaptions_id`: sentence ids in the yjcaptions
+- `sentence1`: premise sentence
+- `sentence2`: hypothesis sentence
+- `label`: inference relation
+
+#### JSQuAD
+
+- `title`: title of a Wikipedia article
+- `paragraphs`: a set of paragraphs
+- `qas`: a set of pairs of a question and its answer
+- `question`: question
+- `id`: id of a question
+- `answers`: a set of answers
+- `text`: answer text
+- `answer_start`: start position (character index)
+- `is_impossible`: all the values are false
+- `context`: a concatenation of the title and paragraph
+
+#### JCommonsenseQA
+
+- `q_id`: ID of the question
+- `question`: question
+- `choice{0..4}`: choice
+- `label`: correct choice id
+
+### Data Splits
+
+From [the official README.md](https://github.com/yahoojapan/JGLUE/blob/main/README.md#tasksdatasets):
+
+> Only train/dev sets are available now, and the test set will be available after the leaderboard is made public.
+
+| Task                         | Dataset        | Train   | Dev   | Test  |
+|------------------------------|----------------|--------:|------:|------:|
+| Text Classification          | MARC-ja        | 187,528 | 5,654 | 5,639 |
+|                              | JCoLA†  | -       | -     | -     |
+| Sentence Pair Classification | JSTS           | 12,451  | 1,457 | 1,589 |
+|                              | JNLI           | 20,073  | 2,434 | 2,508 |
+| Question Answering           | JSQuAD         | 62,859  | 4,442 | 4,420 |
+|                              | JCommonsenseQA | 8,939   | 1,119 | 1,118 |
+
+> †JCoLA will be added soon.
+
+## Dataset Creation
+
+### Curation Rationale
+
+From [the original paper](https://aclanthology.org/2022.lrec-1.317/):
+
+> JGLUE is designed to cover a wide range of GLUE and SuperGLUE tasks and consists of three kinds of tasks: text classification, sentence pair classification, and question answering.
+
+### Source Data
+
+#### Initial Data Collection and Normalization
+
+[More Information Needed]
+
+#### Who are the source language producers?
+
+- The source language producers are users of Amazon (MARC-ja), crowd-workers of Yahoo! Crowdsourcing (JSTS, JNLI and JCommonsenseQA), writers of the Japanese Wikipedia (JSQuAD).
+
+### Annotations
+
+#### Annotation process
+
+##### MARC-ja
+
+From [the original paper](https://aclanthology.org/2022.lrec-1.317/):
+
+> As one of the text classification datasets, we build a dataset based on the Multilingual Amazon Reviews Corpus (MARC) (Keung et al., 2020). MARC is a multilingual corpus of product reviews with 5-level star ratings (1-5) on the Amazon shopping site. This corpus covers six languages, including English and Japanese. For JGLUE, we use the Japanese part of MARC and to make it easy for both humans and computers to judge a class label, we cast the text classification task as a binary classification task, where 1- and 2-star ratings are converted to “negative”, and 4 and 5 are converted to “positive”. We do not use reviews with a 3-star rating. 
+
+> One of the problems with MARC is that it sometimes contains data where the rating diverges from the review text. This happens, for example, when a review with positive content is given a rating of 1 or 2. These data degrade the quality of our dataset. To improve the quality of the dev/test instances used for evaluation, we crowdsource a positive/negative judgment task for approximately 12,000 reviews. We adopt only reviews with the same votes from 7 or more out of 10 workers and assign a label of the maximum votes to these reviews. We divide the resulting reviews into dev/test data. 
+
+> We obtained 5,654 and 5,639 instances for the dev and test data, respectively, through the above procedure. For the training data, we extracted 187,528 instances directly from MARC without performing the cleaning procedure because of the large number of training instances. The statistics of MARC-ja are listed in Table 2. For the evaluation metric for MARC-ja, we use accuracy because it is a binary classification task of texts.
+
+##### JSTS and JNLI
+
+From [the original paper](https://aclanthology.org/2022.lrec-1.317/):
+
+> For the sentence pair classification datasets, we construct a semantic textual similarity (STS) dataset, JSTS, and a natural language inference (NLI) dataset, JNLI.
+
+> ### Overview
+> STS is a task of estimating the semantic similarity of a sentence pair. Gold similarity is usually assigned as an average of the integer values 0 (completely different meaning) to 5 (equivalent meaning) assigned by multiple workers through crowdsourcing.
+
+> NLI is a task of recognizing the inference relation that a premise sentence has to a hypothesis sentence. Inference relations are generally defined by three labels: “entailment”, “contradiction”, and “neutral”. Gold inference relations are often assigned by majority voting after collecting answers from multiple workers through crowdsourcing.
+
+> For the STS and NLI tasks, STS-B (Cer et al., 2017) and MultiNLI (Williams et al., 2018) are included in GLUE, respectively. As Japanese datasets, JSNLI (Yoshikoshi et al., 2020) is a machine translated dataset of the NLI dataset SNLI (Stanford NLI), and JSICK (Yanaka and Mineshima, 2021) is a human translated dataset of the STS/NLI dataset SICK (Marelli et al., 2014). As mentioned in Section 1, these have problems originating from automatic/manual translations. To solve this problem, we construct STS/NLI datasets in Japanese from scratch. We basically extract sentence pairs in JSTS and JNLI from the Japanese version of the MS COCO Caption Dataset (Chen et al., 2015), the YJ Captions Dataset (Miyazaki and Shimizu, 2016). Most of the sentence pairs in JSTS and JNLI overlap, allowing us to analyze the relationship between similarities and inference relations for the same sentence pairs like SICK and JSICK.
+
+> The similarity value in JSTS is assigned a real number from 0 to 5 as in STS-B. The inference relation in JNLI is assigned from the above three labels as in SNLI and MultiNLI. The definitions of the inference relations are also based on SNLI.
+
+> ### Method of Construction
+> Our construction flow for JSTS and JNLI is shown in Figure 1. Basically, two captions for the same image of YJ Captions are used as sentence pairs. For these sentence pairs, similarities and NLI relations of entailment and neutral are obtained by crowdsourcing. However, it is difficult to collect sentence pairs with low similarity and contradiction relations from captions for the same image. To solve this problem, we collect sentence pairs with low similarity from captions for different images. We collect contradiction relations by asking workers to write contradictory sentences for a given caption. 
+
+> The detailed construction procedure for JSTS and JNLI is described below.
+> 1. We crowdsource an STS task using two captions for the same image from YJ Captions. We ask five workers to answer the similarity between two captions and take the mean value as the gold similarity. We delete sentence pairs with a large variance in the answers because such pairs have poor answer quality. We performed this task on 16,000 sentence pairs and deleted sentence pairs with a similarity variance of 1.0 or higher, resulting in the collection of 10,236 sentence pairs with gold similarity. We refer to this collected data as JSTS-A.
+> 2. To collect sentence pairs with low similarity, we crowdsource the same STS task as Step 1 using sentence pairs of captions for different images. We conducted this task on 4,000 sentence pairs and collected 2,970 sentence pairs with gold similarity. We refer to this collected data as JSTS-B.
+> 3. For JSTS-A, we crowdsource an NLI task. Since inference relations are directional, we obtain inference relations in both directions for sentence pairs. As mentioned earlier,it is difficult to collect instances of contradiction from JSTS-A, which was collected from the captions of the same images,and thus we collect instances of entailment and neutral in this step. We collect inference relation answers from 10 workers. If six or more people give the same answer, we adopt it as the gold label if it is entailment or neutral. To obtain inference relations in both directions for JSTS-A, we performed this task on 20,472 sentence pairs, twice as many as JSTS-A. As a result, we collected inference relations for 17,501 sentence pairs. We refer to this collected data as JNLI-A. We do not use JSTS-B for the NLI task because it is difficult to define and determine the inference relations between captions of different images.
+> 4. To collect NLI instances of contradiction, we crowdsource a task of writing four contradictory sentences for each caption in YJCaptions. From the written sentences, we remove sentence pairs with an edit distance of 0.75 or higher to remove low-quality sentences, such as short sentences and sentences with low relevance to the original sentence. Furthermore, we perform a one-way NLI task with 10 workers to verify whether the created sentence pairs are contradictory. Only the sentence pairs answered as contradiction by at least six workers are adopted. Finally,since the contradiction relation has no direction, we automatically assign contradiction in the opposite direction of the adopted sentence pairs. Using 1,800 captions, we acquired 7,200 sentence pairs, from which we collected 3,779 sentence pairs to which we assigned the one-way contradiction relation.By automatically assigning the contradiction relation in the opposite direction, we doubled the number of instances to 7,558. We refer to this collected data as JNLI-C.
+> 5. For the 3,779 sentence pairs collected in Step 4, we crowdsource an STS task, assigning similarity  and filtering in the same way as in Steps1 and 2. In this way, we collected 2,303 sentence pairs with gold similarity from 3,779 pairs. We refer to this collected data as JSTS-C.
+
+##### JSQuAD
+
+From [the original paper](https://aclanthology.org/2022.lrec-1.317/):
+
+> As QA datasets, we build a Japanese version of SQuAD (Rajpurkar et al., 2016), one of the datasets of reading comprehension, and a Japanese version ofCommonsenseQA, which is explained in the next section.
+
+> Reading comprehension is the task of reading a document and answering questions about it. Many reading comprehension evaluation sets have been built in English, followed by those in other languages or multilingual ones.
+
+> In Japanese, reading comprehension datasets for quizzes (Suzukietal.,2018) and those in the drivingdomain (Takahashi et al., 2019) have been built, but none are in the general domain. We use Wikipedia to build a dataset for the general domain. The construction process is basically based on SQuAD 1.1 (Rajpurkar et al., 2016). 
+
+> First, to extract high-quality articles from Wikipedia, we use Nayuki, which estimates the quality of articles on the basis of hyperlinks in Wikipedia. We randomly chose 822 articles from the top-ranked 10,000 articles. For example, the articles include “熊本県 (Kumamoto Prefecture)” and “フランス料理 (French cuisine)”. Next, we divide an article into paragraphs, present each paragraph to crowdworkers, and ask them to write questions and answers that can be answered if one understands the paragraph. Figure 2 shows an example of JSQuAD. We ask workers to write two additional answers for the dev and test sets to make the system evaluation robust.
+
+##### JCommonsenseQA
+
+From [the original paper](https://aclanthology.org/2022.lrec-1.317/):
+
+> ### Overview
+> JCommonsenseQA is a Japanese version of CommonsenseQA (Talmor et al., 2019), which consists of five choice QA to evaluate commonsense reasoning ability. Figure 3 shows examples of JCommonsenseQA. In the same way as CommonsenseQA, JCommonsenseQA is built using crowdsourcing with seeds extracted from the knowledge base ConceptNet (Speer et al., 2017). ConceptNet is a multilingual knowledge base that consists of triplets of two concepts and their relation. The triplets are directional and represented as (source concept, relation, target concept), for example (bullet train, AtLocation, station).
+
+> ### Method of Construction
+> The construction flow for JCommonsenseQA is shown in Figure 4. First, we collect question sets (QSs) from ConceptNet, each of which consists of a source concept and three target concepts that have the same relation to the source concept. Next, for each QS, we crowdAtLocation 2961source a task of writing a question with only one target concept as the answer and a task of adding two distractors. We describe the detailed construction procedure for JCommonsenseQA below, showing how it differs from CommonsenseQA.
+
+> 1. We collect Japanese QSs from ConceptNet. CommonsenseQA uses only forward relations (source concept, relation, target concept) excluding general ones such as “RelatedTo” and “IsA”. JCommonsenseQA similarly uses a set of 22 relations5, excluding general ones, but the direction of the relations is bidirectional to make the questions more diverse. In other words, we also use relations in the opposite direction (source concept, relation−1, target concept).6 With this setup, we extracted 43,566 QSs with Japanese source/target concepts and randomly selected 7,500 from them.
+> 2. Some low-quality questions in CommonsenseQA contain distractors that can be considered to be an answer. To improve the quality of distractors, we add the following two processes that are not adopted in CommonsenseQA. First, if three target concepts of a QS include a spelling variation or a synonym of one another, this QS is removed. To identify spelling variations, we use the word ID of the morphological dictionary Juman Dic7. Second, we crowdsource a task of judging whether target concepts contain a synonym. As a result, we adopted 5,920 QSs from 7,500.
+> 3. For each QS, we crowdsource a task of writing a question sentence in which only one from the three target concepts is an answer. In the example shown in Figure 4, “駅 (station)” is an answer, and the others are distractors. To remove low quality question sentences, we remove the following question sentences.
+>    - Question sentences that contain a choice word(this is because such a question is easily solved).
+>    - Question sentences that contain the expression “XX characters”.8 (XX is a number).
+>    - Improperly formatted question sentences that do not end with “?”.
+>    - As a result, 5,920 × 3 = 17,760question sentences were created, from which we adopted 15,310 by removing inappropriate question sentences.
+> 4. In CommonsenseQA, when adding distractors, one is selected from ConceptNet, and the other is created by crowdsourcing. In JCommonsenseQA, to have a wider variety of distractors, two distractors are created by crowdsourcing instead of selecting from ConceptNet. To improve the quality of the questions9, we remove questions whose added distractors fall into one of the following categories:
+>    - Distractors are included in a question sentence.
+>    - Distractors overlap with one of existing choices.
+>    - As a result, distractors were added to the 15,310 questions, of which we adopted 13,906.
+> 5. We asked three crowdworkers to answer each question and adopt only those answered correctly by at least two workers. As a result, we adopted 11,263 out of the 13,906 questions.
+
+#### Who are the annotators?
+
+From [the official README.md](https://github.com/yahoojapan/JGLUE/blob/main/README.md#tasksdatasets):
+
+> We use Yahoo! Crowdsourcing for all crowdsourcing tasks in constructing the datasets.
+
+### Personal and Sensitive Information
+
+[More Information Needed]
+
+## Considerations for Using the Data
+
+### Social Impact of Dataset
+
+From [the original paper](https://aclanthology.org/2022.lrec-1.317/):
+
+> We build a Japanese NLU benchmark, JGLUE, from scratch without translation to measure the general NLU ability in Japanese. We hope that JGLUE will facilitate NLU research in Japanese.
+
+### Discussion of Biases
+
+[More Information Needed]
+
+### Other Known Limitations
+
+[More Information Needed]
+
+## Additional Information
+
+- 日本語言語理解ベンチマーク JGLUE の構築 〜 自然言語処理モデルの評価用データセットを公開しました - Yahoo! JAPAN Tech Blog https://techblog.yahoo.co.jp/entry/2022122030379907/ 
+
+### Dataset Curators
+
+#### MARC-ja
+
+- Keung, Phillip, et al. "The Multilingual Amazon Reviews Corpus." Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP). 2020.
+
+#### JSTS and JNLI
+
+- Miyazaki, Takashi, and Nobuyuki Shimizu. "Cross-lingual image caption generation." Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). 2016.
+
+#### JSQuAD
+
+The authors curated the original data for JSQuAD from the Japanese wikipedia dump.
+
+#### JCommonsenseQA
+
+In the same way as CommonsenseQA, JCommonsenseQA is built using crowdsourcing with seeds extracted from the knowledge base ConceptNet
+
+### Licensing Information
+
+> This work is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License.
+
+### Citation Information
+
+```bibtex
+@inproceedings{kurihara-etal-2022-jglue,
+    title = "{JGLUE}: {J}apanese General Language Understanding Evaluation",
+    author = "Kurihara, Kentaro  and
+      Kawahara, Daisuke  and
+      Shibata, Tomohide",
+    booktitle = "Proceedings of the Thirteenth Language Resources and Evaluation Conference",
+    month = jun,
+    year = "2022",
+    address = "Marseille, France",
+    publisher = "European Language Resources Association",
+    url = "https://aclanthology.org/2022.lrec-1.317",
+    pages = "2957--2966",
+    abstract = "To develop high-performance natural language understanding (NLU) models, it is necessary to have a benchmark to evaluate and analyze NLU ability from various perspectives. While the English NLU benchmark, GLUE, has been the forerunner, benchmarks are now being released for languages other than English, such as CLUE for Chinese and FLUE for French; but there is no such benchmark for Japanese. We build a Japanese NLU benchmark, JGLUE, from scratch without translation to measure the general NLU ability in Japanese. We hope that JGLUE will facilitate NLU research in Japanese.",
+}
+```
+
+```bibtex
+@InProceedings{Kurihara_nlp2022,
+  author = 	"栗原健太郎 and 河原大輔 and 柴田知秀",
+  title = 	"JGLUE: 日本語言語理解ベンチマーク",
+  booktitle = 	"言語処理学会第 28 回年次大会",
+  year =	"2022",
+  url = "https://www.anlp.jp/proceedings/annual_meeting/2022/pdf_dir/E8-4.pdf"
+  note= "in Japanese"
+}
+```
+
+### Contributions
+
+Thanks to [Kentaro Kurihara](https://twitter.com/kkurihara_cs), [Daisuke Kawahara](https://twitter.com/daisukekawahar1), and [Tomohide Shibata](https://twitter.com/stomohide) for creating this dataset.

pyproject.toml

@@ -0,0 +1,27 @@
+[tool.poetry]
+name = "huggingface-datasets-jglue"
+version = "0.1.0"
+description = ""
+authors = ["Shunsuke KITADA <shunsuke.kitada.0831@gmail.com>"]
+readme = "README.md"
+packages = []
+
+[tool.poetry.dependencies]
+python = "^3.9"
+datasets = "^2.10.0"
+beautifulsoup4 = "^4.11.2"
+mecab-python3 = "^1.0.6"
+pyknp = "^0.6.1"
+mojimoji = "^0.0.12"
+
+
+[tool.poetry.group.dev.dependencies]
+black = "^23.1.0"
+isort = "^5.12.0"
+flake8 = "^6.0.0"
+mypy = "^1.0.1"
+pytest = "^7.2.1"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

tests/JGLUE_test.py

@@ -0,0 +1,69 @@
+import datasets as ds
+import pytest
+
+
+@pytest.fixture
+def dataset_path() -> str:
+    return "JGLUE.py"
+
+
+@pytest.mark.parametrize(
+    argnames="dataset_name, expected_num_train, expected_num_valid,",
+    argvalues=(
+        ("JSTS", 12451, 1457),
+        ("JNLI", 20073, 2434),
+        ("JCommonsenseQA", 8939, 1119),
+    ),
+)
+def test_load_dataset(
+    dataset_path: str,
+    dataset_name: str,
+    expected_num_train: int,
+    expected_num_valid: int,
+):
+    dataset = ds.load_dataset(path=dataset_path, name=dataset_name)
+
+    assert dataset["train"].num_rows == expected_num_train
+    assert dataset["validation"].num_rows == expected_num_valid
+
+
+def test_load_jsquad(
+    dataset_path: str,
+    dataset_name: str = "JSQuAD",
+    expected_num_train: int = 62859,
+    expected_num_valid: int = 4442,
+):
+    dataset = ds.load_dataset(path=dataset_path, name=dataset_name)
+
+    def count_num_data(split: str) -> int:
+        data = dataset[split]["data"]
+        assert len(data) == 1
+        data = data[0]
+
+        num_data = 0
+        for paragraphs in data["paragraphs"]:
+            for qas in paragraphs["qas"]:
+                num_data += len(qas["answers"])
+        return num_data
+
+    assert count_num_data("train") == expected_num_train
+    assert count_num_data("validation") == expected_num_valid
+
+
+def test_load_marc_ja(
+    dataset_path: str,
+    dataset_name: str = "MARC-ja",
+    expected_num_train: int = 187528,
+    expected_num_valid: int = 5654,
+):
+    dataset = ds.load_dataset(
+        path=dataset_path,
+        name=dataset_name,
+        is_pos_neg=True,
+        max_char_length=500,
+        filter_review_id_list_valid=True,
+        label_conv_review_id_list_valid=True,
+    )
+
+    assert dataset["train"].num_rows == expected_num_train
+    assert dataset["validation"].num_rows == expected_num_valid