Upload m3ls.py with huggingface_hub

m3ls.py

@@ -0,0 +1,403 @@
+"""
+SEACrowd Data Loader for M3LS.
+"""
+import json
+import os
+from collections.abc import Iterable
+from copy import deepcopy
+from typing import Dict, Generator, List, Tuple, Union
+
+try:
+    import PIL
+except (ImportError, ModuleNotFoundError):
+    print("Please install `PIL` to load image-based data from M3LS dataloader.")
+else:
+    PIL.__version__  # to avoid being marked by formatter
+
+import datasets
+from datasets.download.download_manager import DownloadManager
+
+from seacrowd.utils import schemas
+from seacrowd.utils.configs import SEACrowdConfig
+from seacrowd.utils.constants import TASK_TO_SCHEMA, Licenses, Tasks
+
+_CITATION = r"""
+@inproceedings{verma-etal-2023-large,
+    title = "Large Scale Multi-Lingual Multi-Modal Summarization Dataset",
+    author = "Verma, Yash  and
+      Jangra, Anubhav  and
+      Verma, Raghvendra  and
+      Saha, Sriparna",
+    editor = "Vlachos, Andreas  and
+      Augenstein, Isabelle",
+    booktitle = "Proceedings of the 17th Conference of the European Chapter of the Association for Computational Linguistics",
+    month = may,
+    year = "2023",
+    address = "Dubrovnik, Croatia",
+    publisher = "Association for Computational Linguistics",
+    url = "https://aclanthology.org/2023.eacl-main.263",
+    doi = "10.18653/v1/2023.eacl-main.263",
+    pages = "3620--3632",
+}
+"""
+
+logger = datasets.logging.get_logger(__name__)
+
+_LOCAL = False
+_LANGUAGES = ["ind"]
+
+
+_DATASETNAME = "m3ls"
+_DESCRIPTION = r"""
+The multilingual multimodal summarization dataset (M3LS) consists of over a million instances of document-image pairs
+along with a professionally annotated multimodal summary for each pair.
+It is derived from news articles published by the British Broadcasting Corporation (BBC) over a decade and spans 20 total languages,
+which Indonesian is the only SEA language available on this dataset.
+"""
+
+_HOMEPAGE = "https://github.com/anubhav-jangra/M3LS/tree/main"
+_LICENSE = Licenses.MIT.value
+
+_URL = "https://drive.google.com/uc?id=1Kznkw7YpRiWpdgH4_SVNwp0uGf3j-5e2"
+
+_SUPPORTED_TASKS = [Tasks.SUMMARIZATION, Tasks.IMAGE_CAPTIONING]
+_SOURCE_VERSION = "1.0.0"
+_SEACROWD_VERSION = "2024.06.20"
+
+_CONFIG_SUFFIXES_FOR_TASK = [TASK_TO_SCHEMA.get(task).lower() for task in _SUPPORTED_TASKS]
+
+
+class M3LSDataset(datasets.GeneratorBasedBuilder):
+    """M3LS dataset of Indonesian Language (from BBC Indonesian)"""
+
+    BUILDER_CONFIGS = [
+        SEACrowdConfig(
+            name=f"{_DATASETNAME}_source",
+            version=datasets.Version(_SOURCE_VERSION),
+            description=f"{_DATASETNAME} source schema",
+            schema="source",
+            subset_id=f"{_DATASETNAME}",
+        ),
+        *[
+            SEACrowdConfig(
+                name=f"{_DATASETNAME}_seacrowd_{cfg_sufix}",
+                version=datasets.Version(_SEACROWD_VERSION),
+                description=f"{_DATASETNAME} seacrowd schema for {task.name}",
+                schema=f"seacrowd_{cfg_sufix}",
+                subset_id=f"{_DATASETNAME}",
+            )
+            for task, cfg_sufix in zip(_SUPPORTED_TASKS, _CONFIG_SUFFIXES_FOR_TASK)
+        ],
+    ]
+
+    def _info(self) -> datasets.DatasetInfo:
+        _config_schema_name = self.config.schema
+        logger.info(f"Received schema name: {self.config.schema}")
+
+        if _config_schema_name == "source":
+            features = datasets.Features(
+                {
+                    "id": datasets.Value("string"),
+                    "date": datasets.Value("string"),
+                    "url": datasets.Value("string"),
+                    "title": datasets.Value("string"),
+                    "summary": datasets.Value("string"),
+                    "keyword": datasets.Sequence(datasets.Value("string")),
+                    "related": datasets.Sequence(datasets.Value("string")),
+                    "section_headers": datasets.Sequence(datasets.Value("string")),
+                    "paragraphs": datasets.Sequence(datasets.Value("string")),
+                    "images": datasets.Sequence(datasets.Image()),
+                    "captions": datasets.Sequence(datasets.Value("string")),
+                }
+            )
+
+        # speech-text schema
+        elif _config_schema_name == "seacrowd_t2t":
+            features = schemas.text2text_features
+
+        elif _config_schema_name == "seacrowd_imtext":
+            features = schemas.image_text_features()
+
+        else:
+            raise ValueError(f"Received unexpected config schema of {_config_schema_name}!")
+
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=features,
+            homepage=_HOMEPAGE,
+            license=_LICENSE,
+            citation=_CITATION,
+        )
+
+    def _split_generators(self, dl_manager: DownloadManager) -> List[datasets.SplitGenerator]:
+        try:
+            import gdown
+        except ImportError:
+            raise ImportError("Please install `gdown` to enable downloading data from google drive.")
+
+        # Download from Google drive
+        output_dir = os.path.join(os.getcwd(), "data", "m3ls")
+        if not os.path.exists(output_dir):
+            os.makedirs(output_dir)
+        output_file = output_dir + "/m3ls.zip"
+        if not os.path.exists(output_file):
+            gdown.download(_URL, str(output_file), fuzzy=True)
+        else:
+            logger.info(f"File already downloaded: {str(output_file)}")
+
+        local_path = os.path.join(dl_manager.extract(output_file).title(), "bbcindonesia")
+
+        # there are two folders all containing json files, namely "processed" and "articles"
+        # both are having articles info with url, text, and accompanied resource scrapped (i.e image & captions, related articles)
+
+        # the "processed" contains only 244 data, which 156 of them doesn't have any title info
+        # whereas "articles" contains 56108 data (the same reported as the wholly data in paper), all having title info
+
+        # no intersection of links for both, nor information provided, hence we will only take "articles" due to matched info w/ their paper
+        # the original paper mentioned 80:10:10 splits for over, but there is no info for such splitting index on the extracted folder
+        article_data_dir = os.path.join(local_path, "articles")
+
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={
+                    "article_data_dir": article_data_dir,
+                    "image_folder": os.path.join(local_path, "imagefolder"),
+                },
+            )
+        ]
+
+    def _generate_examples(self, article_data_dir: str, image_folder: str) -> Generator[Tuple[int, Dict], None, None]:
+        _config_schema_name = self.config.schema
+        all_image_filename = os.listdir(image_folder)
+
+        idx = 1
+        im_data_idx = 1
+        for filename in os.listdir(article_data_dir):
+            root_data, content_data = self.__json_read_and_process(os.path.join(article_data_dir, filename))
+
+            # for images, it has around 6.7% missing rate (15625 out of 230163)
+            if _config_schema_name == "source":
+                content_data = self.__m3ls_content_data_reconstructor_and_validator(content_data, mode="all")
+                image_path, captions = self.__m3ls_filter_image_and_captions_data(content_data["image_paths"], content_data["captions"], image_folder, all_image_filename)
+
+                yield idx, {
+                    "id": idx,
+                    "date": root_data["date"],
+                    "url": root_data["url"],
+                    "title": root_data["title"],
+                    "summary": root_data["summary"],
+                    "keyword": root_data["keyword"],
+                    "related": root_data["related"],
+                    "section_headers": content_data["section_headers"],
+                    "paragraphs": content_data["paragraphs"],
+                    "images": image_path,
+                    "captions": captions,
+                }
+
+            elif _config_schema_name == "seacrowd_t2t":
+                content_data = self.__m3ls_content_data_reconstructor_and_validator(content_data, mode="text")
+                yield idx, {
+                    "id": idx,
+                    "text_1": "\n".join(content_data["paragraphs"]),
+                    "text_2": root_data["summary"],
+                    "text_1_name": "texts",
+                    "text_2_name": "summary",
+                }
+
+            elif _config_schema_name == "seacrowd_imtext":
+                content_data = self.__m3ls_content_data_reconstructor_and_validator(content_data, mode="image")
+                image_path, captions = self.__m3ls_filter_image_and_captions_data(content_data["image_paths"], content_data["captions"], image_folder, all_image_filename, both_exists=True)
+
+                if image_path == []:
+                    continue
+
+                for path_idx in range(len(image_path)):
+                    yield im_data_idx, {
+                        "id": im_data_idx,
+                        "image_paths": [image_path[path_idx]],
+                        "texts": captions[path_idx],
+                        "metadata": {
+                            "context": root_data["url"],
+                            "labels": None,
+                        },
+                    }
+                    im_data_idx += 1
+
+            else:
+                raise ValueError(f"Received unexpected config schema of {_config_schema_name}!")
+
+            idx += 1
+
+    @staticmethod
+    def __check_only_1level_iterables(iter_obj):
+        return all([not isinstance(data, Iterable) or isinstance(data, str) for data in iter_obj])
+
+    @classmethod
+    def __json_read_and_process(cls, path: str) -> Dict:
+
+        # to check (for compulsory keys) and reconstruct (for optional keys) the json data
+        def base_data_reconstructor(json_data: dict, return_split: bool = True) -> Union[Dict, Tuple[Dict, Dict]]:
+
+            # for detecting content-based dict-keys (it's denoted by int-based keys in string type)
+            def parse_or_check_int(val: Union[int, str, float], is_parse: bool = True):
+                try:
+                    int(val)
+                except (ValueError, TypeError):
+                    return val if is_parse else False
+                else:
+                    return int(val) if is_parse else True
+
+            compulsory_keys = ["summary", "url", "title"]
+            optional_keys = ["date", "keyword", "related"]
+            optional_key_mapper = list(zip(optional_keys, ["Not available", [], []]))
+
+            if any(key not in json_data.keys() for key in compulsory_keys):
+                raise KeyError(f"Missing keys of {list(set(compulsory_keys).difference(json_data.keys()))}")
+
+            for key, default_val in optional_key_mapper:
+                _existing_val = json_data.get(key)
+                new_data = {key: json_data.get(key) if _existing_val is not None else default_val}
+                json_data.update(new_data)
+
+            all_content_keys = [key for key in json_data.keys() if parse_or_check_int(key, is_parse=False)]
+
+            if sorted(compulsory_keys + optional_keys + all_content_keys) != sorted(json_data.keys()):
+                raise KeyError("Some keys are unexpectedly missing or present!")
+
+            content_data = {key: json_data[key] for key in all_content_keys}
+
+            if not return_split:
+                json_data.update(content_data)
+                return json_data
+            else:
+                root_data = {key: val for key, val in json_data.items() if key not in all_content_keys}
+                return root_data, content_data
+
+        def non_content_data_validator(json_data: dict):
+            non_content_dtypes = [("url", str), ("title", str), ("date", str), ("summary", str), ("keyword", list), ("related", list)]
+
+            for key, _type in non_content_dtypes:
+                if not isinstance(json_data[key], _type):
+                    raise TypeError(f"The dict has key {key} that doesn't match with expected type {_type}!")
+
+                # assert only 1-level for list types
+                if _type == list:
+                    if not cls.__check_only_1level_iterables(json_data[key]):
+                        raise ValueError(f"Found iterables in {key} for val {json_data[key]}")
+
+        with open(path, "r") as f:
+            json_input = json.load(f)
+
+        base_data, content_data = base_data_reconstructor(json_input)
+
+        non_content_data_validator(base_data)
+
+        return base_data, content_data
+
+    @classmethod
+    def __m3ls_content_data_reconstructor_and_validator(cls, json_content_data: Dict, mode: str = "all") -> Dict:
+        # `mode` variable scope will be shared to all subfunctions under this fn
+        if mode not in ("all", "image", "text"):
+            raise ValueError("Unexpected `mode`! Accepted: 'all', 'image', or 'text'.")
+
+        all_content_ftrs = ("images", "para", "subheading")
+        expected_dtypes = (list, list, str)
+        default_values = ([["", ""]], [], "")
+
+        _all_ftr_validation_info = {all_content_ftrs[_idx]: {"dtype": expected_dtypes[_idx], "default_val": default_values[_idx]} for _idx in range(len(all_content_ftrs))}
+
+        if mode == "all":
+            ftr_idx = list(range(3))
+        elif mode == "image":
+            ftr_idx = list(range(1))
+        elif mode == "text":
+            ftr_idx = list(range(1, 3))
+
+        ftr_validation_info = {all_content_ftrs[_idx]: _all_ftr_validation_info[all_content_ftrs[_idx]] for _idx in ftr_idx}
+
+        def content_data_reconstructor(json_data: dict):
+            json_data = deepcopy(json_data)
+
+            for key, content_dict in json_data.items():
+                for ftr, ftr_info in ftr_validation_info.items():
+                    if content_dict.get(ftr) is None:
+                        json_data[key][ftr] = ftr_info["default_val"]
+
+            return json_data
+
+        def content_data_validator(content_data: dict):
+            for content_dict in content_data.values():
+                if not isinstance(content_dict, dict):
+                    raise TypeError("Unexpected type found on content data!")
+
+                for ftr_name, ftr_info in ftr_validation_info.items():
+                    _type = ftr_info["dtype"]
+                    if not isinstance(content_dict[ftr_name], _type):
+                        raise TypeError(f"Unexpected type found on content {ftr_name} data! Expected {_type}, got {type(content_dict[ftr_name])}")
+
+                if "para" in ftr_validation_info.keys() and not cls.__check_only_1level_iterables(content_dict["para"]):
+                    raise ValueError("Found iterable in the 'paragraph' data!")
+
+                if "images" in ftr_validation_info.keys() and not all([isinstance(image_data, list) for image_data in content_dict["images"]]):
+                    raise ValueError("Found non-list in the 'images' data!")
+
+                if "images" in ftr_validation_info.keys() and not all([len(image_data) == 2 for image_data in content_dict["images"]]):
+                    raise ValueError("Found non-paired tuples in the 'images' data!")
+
+                if "images" in ftr_validation_info.keys() and not all([cls.__check_only_1level_iterables(image_data) for image_data in content_dict["images"]]):
+                    raise ValueError("Found iterable in the 'images' individual data!")
+
+        def m3ls_content_data_post_process(content_data: dict) -> Dict:
+            output_json = {}
+            for _ftr in ftr_validation_info.keys():
+                output_data = []
+                for value in content_data.values():
+                    output_data.append(value[_ftr])
+                output_json[_ftr] = output_data
+
+            # post process each features
+            if "para" in ftr_validation_info.keys():
+                paragraphs = []
+                for section_data in output_json.pop("para"):
+                    paragraphs.append("".join([val for val in section_data if val.strip() != ""]))
+                output_json["paragraphs"] = paragraphs
+
+            if "images" in ftr_validation_info.keys():
+                list_image_paths = []
+                list_captions = []
+                for sectioned_data in output_json.pop("images"):
+                    for val in sectioned_data:
+                        list_image_paths.append(val[0])
+                        list_captions.append("" if val[1] is None else val[1].strip())
+                output_json["image_paths"] = list_image_paths
+                output_json["captions"] = list_captions
+
+            if "subheading" in ftr_validation_info.keys():
+                output_json["section_headers"] = output_json.pop("subheading")
+
+            return output_json
+
+        content_data = content_data_reconstructor(json_content_data)
+
+        content_data_validator(content_data)
+
+        content_data = m3ls_content_data_post_process(content_data)
+
+        return content_data
+
+    @staticmethod
+    def __m3ls_filter_image_and_captions_data(image_data: list, captions_data: list, base_image_folder: str, all_images: list, both_exists: bool = False) -> Tuple[List, List]:
+        image_path, captions = [], []
+
+        if len(captions_data) != len(image_data):
+            raise ValueError("Not a 1-1 mapping of image-captions!")
+
+        for idx, img_path in enumerate(image_data):
+            if img_path in all_images:
+                if both_exists and captions_data[idx] == "":
+                    continue
+                image_path.append(os.path.join(base_image_folder, img_path))
+                captions.append(captions_data[idx])
+
+        return image_path, captions