Create preprocess_marc_ja.py

preprocess_marc_ja.py

@@ -0,0 +1,261 @@
+"""
+This code is licensed under CC-BY-4.0 from the original work by shunk031.
+The code is adapted from https://huggingface.co/datasets/shunk031/JGLUE/blob/main/JGLUE.py
+with minor modifications to the code structure.
+This codebase provides pre-processing functionality for the MARC-ja dataset in the Japanese GLUE benchmark.
+The original code can be found at https://github.com/yahoojapan/JGLUE/blob/main/preprocess/marc-ja/scripts/marc-ja.py.
+"""
+
+import random
+import warnings
+from typing import Dict, List, Optional, Union
+import string
+
+import datasets as ds
+import pandas as pd
+
+
+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,
+        remove_netural: 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,
+        )
+        if train_ratio + val_ratio + test_ratio != 1.0:
+            raise ValueError(
+                "train_ratio + val_ratio + test_ratio should be 1.0, "
+                f"but got {train_ratio} + {val_ratio} + {test_ratio} = {train_ratio + val_ratio + test_ratio}"
+            )
+
+        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.remove_netural = remove_netural
+        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, remove_netural: bool = False) -> Optional[str]:
+    if rating >= 4:
+        return "positive"
+    elif rating <= 2:
+        return "negative"
+    else:
+        if remove_netural:
+            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", 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_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.remove_netural)))
+
+    # 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