DUDE_loader.py

# coding=utf-8
# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""DUDE dataset loader"""

import copy
import json
import os
from typing import List, Literal

import datasets
import pdf2image
from tqdm import tqdm

_CITATION = """
@inproceedings{dude2023icdar,
    title={ICDAR 2023 Challenge on Document UnderstanDing of Everything (DUDE)},
    author={Van Landeghem, Jordy et . al.},
    booktitle={Proceedings of the ICDAR},
    year={2023}
}
"""

_DESCRIPTION = """\
DUDE requires models to reason and understand about document layouts in multi-page images/PDFs to answer questions about them.
Specifically, models need to incorporate a new modality of layout present in the images/PDFs and reason
over it to answer DUDE questions. 
"""  # DUDE Contains X questions and Y and ...

_HOMEPAGE = "https://rrc.cvc.uab.es/?ch=23"

_LICENSE = "CC BY 4.0"

_SPLITS = ["train", "val", "test"]

_URLS = {
    "binaries": "https://huggingface.co/datasets/jordyvl/DUDE_loader/resolve/main/data/DUDE_train-val-test_binaries.tar.gz",
    "annotations": "https://zenodo.org/record/7763635/files/2023-03-23_DUDE_gt_test_PUBLIC.json?download=1"
    # "blind": "/home/jordy/code/DUchallenge/DUDEeval/gt/2023-03-07_DUDE_gt_release-candidate_NOTSHARABLE.json",
}

SKIP_DOC_IDS = [
    "nan",
    "ef03364aa27a0987c9870472e312aceb",
    "5c5a5880e6a73b4be2315d506ab0b15b",
]


def parse_bbox(bbox):

    if bbox in [[], [[]]]:
        return None

    answers_page_bounding_boxes = []

    if isinstance(bbox[0], list):
        bbox = bbox[0]

    keys = ["left", "top", "width", "height", "page"]

    for page_bb in bbox:
        if len(page_bb) == 0:
            continue
        page_bb = {key: page_bb[key] for key in keys}
        answers_page_bounding_boxes.append(page_bb)
    return answers_page_bounding_boxes


def batched_conversion(pdf_file):
    info = pdf2image.pdfinfo_from_path(pdf_file, userpw=None, poppler_path=None)
    maxPages = info["Pages"]

    images = []

    for page in range(1, maxPages + 1, 10):
        images.extend(
            pdf2image.convert_from_path(
                pdf_file,
                dpi=200,
                first_page=page,
                last_page=min(page + 10 - 1, maxPages),
            )
        )
    return images


def open_pdf_binary(pdf_file):
    with open(pdf_file, "rb") as f:
        return f.read()


class DUDEConfig(datasets.BuilderConfig):
    """BuilderConfig for DUDE."""

    def __init__(
        self,
        binary_mode: bool = False,
        ocr_engine: Literal["Azure", "Amazon", "Tesseract"] = "Amazon",
        format: Literal["original", "due"] = "original",
        **kwargs,
    ):
        """BuilderConfig for DUDE.
        Args:
          binary_mode: `boolean`, load binary PDFs/OCR or pass along paths on local file system
          **kwargs: keyword arguments forwarded to super.
        """
        super(DUDEConfig, self).__init__(description=_DESCRIPTION, **kwargs)
        self.binary_mode = binary_mode
        self.ocr_engine = ocr_engine
        self.format = format


def builder_configs(version):
    configurations = []
    for binary_mode in [True, False]:
        for ocr_engine in ["Azure", "Amazon", "Tesseract"]:
            for format in ["original", "due"]:
                binary_name = "bin_" if binary_mode else ""
                configurations.append(
                    DUDEConfig(
                        name=f"{binary_name}{ocr_engine}_{format}",
                        version=version,
                        binary_mode=binary_mode,
                        ocr_engine=ocr_engine,
                        format=format,
                    )
                )
    return configurations


class DUDE(datasets.GeneratorBasedBuilder):
    """DUDE dataset."""

    VERSION = datasets.Version("1.0.7")

    BUILDER_CONFIGS = builder_configs(VERSION)

    DEFAULT_CONFIG_NAME = (
        "Amazon_original"  # for some reason not working, need to pass a config anyway
    )

    def _info(self):
        features = datasets.Features(
            {
                "docId": datasets.Value("string"),
                "questionId": datasets.Value("string"),
                "question": datasets.Value("string"),
                "answers": datasets.Sequence(datasets.Value("string")),
                "answers_page_bounding_boxes": datasets.Sequence(
                    {
                        "left": datasets.Value("int32"),
                        "top": datasets.Value("int32"),
                        "width": datasets.Value("int32"),
                        "height": datasets.Value("int32"),
                        "page": datasets.Value("int32"),
                    }
                ),
                "answers_variants": datasets.Sequence(datasets.Value("string")),
                "answer_type": datasets.Value("string"),
                "data_split": datasets.Value("string"),
                "document": datasets.Value("binary")
                if self.config.binary_mode
                else datasets.Value("string"),
                "OCR": datasets.Value("binary")
                if self.config.binary_mode
                else datasets.Value("string"),
            }
        )

        return datasets.DatasetInfo(
            description=_DESCRIPTION,
            features=features,
            supervised_keys=None,
            homepage=_HOMEPAGE,
            license=_LICENSE,
            citation=_CITATION,
        )

    def _split_generators(
        self, dl_manager: datasets.DownloadManager
    ) -> List[datasets.SplitGenerator]:

        if "blind" in _URLS and os.path.exists(_URLS[f"blind"]):
            annotations = json.load(open(_URLS[f"blind"], "r"))
        else:
            annotations = json.load(open(_URLS[f"annotations"], "r"))

        if self.config.data_dir:  # when unpacked to a custom directory
            binary_extraction_path = self.config.data_dir
        else:
            binaries_path = dl_manager.download(_URLS["binaries"])
            binary_extraction_path = dl_manager.extract(binaries_path)
            # binaries_archive = dl_manager.iter_archive(binaries_path)

        splits = []
        for split in _SPLITS:
            splits.append(
                datasets.SplitGenerator(
                    name=split,
                    gen_kwargs={
                        "binary_extraction_path": binary_extraction_path,
                        "annotations": annotations,
                        "split": split,
                    },
                )
            )
        return splits

    def _generate_examples(self, binary_extraction_path, annotations, split):
        def retrieve_doc(docid):
            extracted_path = os.path.join(
                binary_extraction_path, "PDF", split, docid + ".pdf"
            )
            return extracted_path

        def retrieve_OCR(docid, ocr_engine="Amazon", format="original"):
            extracted_path = os.path.join(
                binary_extraction_path, "OCR", ocr_engine, docid + f"_{format}.json"
            )
            return extracted_path

        annotations = annotations['data'] if isinstance(annotations, dict) else annotations

        split_condition = (
            lambda x, split: bool(x["data_split"] == split)
            if split in ["train", "val"]
            else bool(split in x["data_split"])
        )  # test, test2; only relevant for blind set
        annotations = [x for x in annotations if split_condition(x, split)]

        for i, a in enumerate(annotations):
            if a["docId"] in SKIP_DOC_IDS:
                continue
            a = dict(a)
            a["data_split"] = split
            if not "answers" in a.keys():  # test set has no ground truth provided
                a["answers"] = None
                a["answers_variants"] = None
                a["answer_type"] = None
                a["answers_page_bounding_boxes"] = None
            else:
                a["answers_page_bounding_boxes"] = parse_bbox(
                    a.get("answers_page_bounding_boxes", [])
                )
            docpath = retrieve_doc(a["docId"])
            ocrpath = retrieve_OCR(a["docId"])
            if self.config.binary_mode:
                with open(docpath, "rb") as f, open(ocrpath, "rb") as g:
                    a["document"] = f.read()
                    a["OCR"] = g.read()
            else:
                a["document"] = docpath
                a["OCR"] = ocrpath
            yield i, a