Create new file

xfund.py

@@ -0,0 +1,152 @@
+# Lint as: python3
+import json
+import logging
+import os
+
+import datasets
+from detectron2.data.detection_utils import read_image
+from detectron2.data.transforms import ResizeTransform, TransformList
+from torch import tensor
+
+
+def load_image(image_path):
+    image = read_image(image_path, format="BGR")
+    h = image.shape[0]
+    w = image.shape[1]
+    img_trans = TransformList([ResizeTransform(h=h, w=w, new_h=224, new_w=224)])
+    # convert to RGB
+    image = tensor(img_trans.apply_image(image).copy()).permute(
+        2, 0, 1
+    )  # copy to make it writeable
+    return image, (w, h)
+
+
+_URL = "https://github.com/doc-analysis/XFUND/releases/download/v1.0/"
+
+_LANG = ["zh", "de", "es", "fr", "en", "it", "ja", "pt"]
+logger = logging.getLogger(__name__)
+
+
+class XFUNDConfig(datasets.BuilderConfig):
+    """BuilderConfig for XFUND."""
+
+    def __init__(self, lang, additional_langs=None, **kwargs):
+        """
+        Args:
+            lang: string, language for the input text
+            **kwargs: keyword arguments forwarded to super.
+        """
+        super().__init__(**kwargs)
+        self.lang = lang
+        self.additional_langs = additional_langs
+
+
+_LABELS = ["header", "question", "answer", "other"]
+
+
+def _get_box_feature():
+    return datasets.Sequence(datasets.Value("int64"))
+
+
+class XFUND(datasets.GeneratorBasedBuilder):
+    """XFUND dataset."""
+
+    BUILDER_CONFIGS = [XFUNDConfig(name=f"xfund.{lang}", lang=lang) for lang in _LANG]
+
+    def _info(self):
+        return datasets.DatasetInfo(
+            features=datasets.Features(
+                {
+                    "id": datasets.Value("string"),
+                    "uid": datasets.Value("string"),
+                    "document": datasets.Sequence(
+                        {
+                            "id": datasets.Value("int64"),
+                            "box": _get_box_feature(),
+                            "text": datasets.Value("string"),
+                            "label": datasets.ClassLabel(names=_LABELS),
+                            "words": datasets.Sequence(
+                                {
+                                    "box": _get_box_feature(),
+                                    "text": datasets.Value("string"),
+                                }
+                            ),
+                            "linking": datasets.Sequence(
+                                datasets.Sequence(datasets.Value("int64"))
+                            ),
+                        }
+                    ),
+                    "img_meta": {
+                        "fname": datasets.Value("string"),
+                        "width": datasets.Value("int64"),
+                        "height": datasets.Value("int64"),
+                        "format": datasets.Value("string"),
+                    },
+                    # has to be at the root level, crashes otherwise
+                    "img_data": datasets.Array3D(shape=(3, 224, 224), dtype="uint8"),
+                },
+            ),
+            supervised_keys=None,
+        )
+
+    def _split_generators(self, dl_manager):
+        """Returns SplitGenerators."""
+        urls_to_download = {
+            "train": [
+                f"{_URL}{self.config.lang}.train.json",
+                f"{_URL}{self.config.lang}.train.zip",
+            ],
+            "val": [f"{_URL}{self.config.lang}.val.json", f"{_URL}{self.config.lang}.val.zip"],
+            # "test": [f"{_URL}{self.config.lang}.test.json", f"{_URL}{self.config.lang}.test.zip"],
+        }
+        downloaded_files = dl_manager.download_and_extract(urls_to_download)
+        train_files_for_many_langs = [downloaded_files["train"]]
+        val_files_for_many_langs = [downloaded_files["val"]]
+        # test_files_for_many_langs = [downloaded_files["test"]]
+        if self.config.additional_langs:
+            additional_langs = self.config.additional_langs.split("+")
+            if "all" in additional_langs:
+                additional_langs = [lang for lang in _LANG if lang != self.config.lang]
+            for lang in additional_langs:
+                urls_to_download = {
+                    "train": [f"{_URL}{lang}.train.json", f"{_URL}{lang}.train.zip"]
+                }
+                additional_downloaded_files = dl_manager.download_and_extract(urls_to_download)
+                train_files_for_many_langs.append(additional_downloaded_files["train"])
+
+        logger.info(
+            f"Training on {self.config.lang} with additional langs({self.config.additional_langs})"
+        )
+        logger.info(f"Evaluating on {self.config.lang}")
+        logger.info(f"Testing on {self.config.lang}")
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN, gen_kwargs={"filepaths": train_files_for_many_langs}
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.VALIDATION, gen_kwargs={"filepaths": val_files_for_many_langs}
+            ),
+            # datasets.SplitGenerator(name=datasets.Split.TEST, gen_kwargs={"filepaths": test_files_for_many_langs}),
+        ]
+
+    def _generate_examples(self, filepaths):
+        for filepath in filepaths:
+            logger.info("Generating examples from = %s", filepath)
+            with open(filepath[0], encoding="utf-8") as f:
+                data = json.load(f)
+
+            for doc in data["documents"]:
+                # print(json.dumps(doc, indent=2))
+                fpath = os.path.join(filepath[1], doc["img"]["fname"])
+                image, size = load_image(fpath)
+                expected_size = tuple([doc["img"]["width"], doc["img"]["height"]])
+                if size != expected_size:
+                    raise ValueError(
+                        f"image has unexpected size: {size}. expected: {expected_size}"
+                    )
+
+                doc["img_meta"] = doc.pop("img")
+                doc["img_meta"]["format"] = "RGB"
+                doc["img_data"] = image
+
+                yield doc["id"], doc