sleukrith_ocr.py

# coding=utf-8
# Copyright 2022 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.

import struct
from pathlib import Path
from typing import Dict, List, Tuple

import datasets
import numpy as np

from seacrowd.utils import schemas
from seacrowd.utils.configs import SEACrowdConfig
from seacrowd.utils.constants import TASK_TO_SCHEMA, Licenses, Tasks

_CITATION = """\
@inproceedings{10.1145/3151509.3151510,
    author = {Valy, Dona and Verleysen, Michel and Chhun, Sophea and Burie, Jean-Christophe},
    title = {A New Khmer Palm Leaf Manuscript Dataset for Document Analysis and Recognition: SleukRith Set},
    year = {2017},
    isbn = {9781450353908},
    publisher = {Association for Computing Machinery},
    address = {New York, NY, USA},
    url = {https://doi.org/10.1145/3151509.3151510},
    doi = {10.1145/3151509.3151510},
    booktitle = {Proceedings of the 4th International Workshop on Historical Document Imaging and Processing},
    pages = {1-6},
    numpages = {6},
    location = {Kyoto, Japan},
    series = {HIP '17}
}
"""

_DATASETNAME = "sleukrith_ocr"

_DESCRIPTION = """\
SleukRith Set is the first dataset specifically created for Khmer palm leaf
manuscripts. The dataset consists of annotated data from 657 pages of digitized
palm leaf manuscripts which are selected arbitrarily from a large collection of
existing and also recently digitized images. The dataset contains three types of
data: isolated characters, words, and lines. Each type of data is annotated with
the ground truth information which is very useful for evaluating and serving as
a training set for common document analysis tasks such as character/text
recognition, word/line segmentation, and word spotting.

The character mapping (per label) is not explained anywhere in the dataset homepage,
thus the labels are simply numbered from 0 to 110, each corresponds to a distinct character.
"""

_HOMEPAGE = "https://github.com/donavaly/SleukRith-Set"

_LANGUAGES = ["khm"]

_LICENSE = Licenses.UNKNOWN.value

_LOCAL = False

_URLS = {
    # this URL corresponds to the raw unprocessed data (whole images); unused in this dataloader
    "sleukrith-set": {
        "images": "https://drive.google.com/uc?export=download&id=19JIxAjjXWuJ7mEyUl5-xRr2B8uOb-GKk",  # 1GB
        "annotated-data": "https://drive.google.com/uc?export=download&id=1Xi5ucRUb1e9TUU-nv2rCUYv2ANVsXYDk",  # 11.7MB
    },
    # this URL corresponds to the processed data (per characters); used in this dataloader
    "isolated-characters": {
        "images_train": "https://drive.google.com/uc?export=download&id=1KXf5937l-Xu_sXsGPuQOgFt4zRaXlSJ5",  # 249MB
        "images_test": "https://drive.google.com/uc?export=download&id=1KSt5AiRIilRryh9GBcxyUUhnbiScdQ-9",  # 199MB
        "labels_train": "https://drive.google.com/uc?export=download&id=1IbmLg-4l-3BtRhprDWWvZjCp7lqap0Z-",  # 442KB
        "labels_test": "https://drive.google.com/uc?export=download&id=1GYcaUInkxtuuQps-qA38u-4zxK7HgrAB",  # 354KB
    },
}

_SUPPORTED_TASKS = [Tasks.OPTICAL_CHARACTER_RECOGNITION]
_SEACROWD_SCHEMA = f"seacrowd_{TASK_TO_SCHEMA[_SUPPORTED_TASKS[0]].lower()}"  # imtext

_SOURCE_VERSION = "1.0.0"

_SEACROWD_VERSION = "2024.06.20"


class SleukRithSet(datasets.GeneratorBasedBuilder):
    """Annotated OCR dataset from 657 pages of digitized Khmer palm leaf manuscripts."""

    SOURCE_VERSION = datasets.Version(_SOURCE_VERSION)
    SEACROWD_VERSION = datasets.Version(_SEACROWD_VERSION)

    BUILDER_CONFIGS = [
        SEACrowdConfig(
            name=f"{_DATASETNAME}_source",
            version=SOURCE_VERSION,
            description=f"{_DATASETNAME} source schema",
            schema="source",
            subset_id=_DATASETNAME,
        ),
        SEACrowdConfig(
            name=f"{_DATASETNAME}_{_SEACROWD_SCHEMA}",
            version=SEACROWD_VERSION,
            description=f"{_DATASETNAME} SEACrowd schema",
            schema=_SEACROWD_SCHEMA,
            subset_id=_DATASETNAME,
        ),
    ]

    DEFAULT_CONFIG_NAME = f"{_DATASETNAME}_source"

    def _info(self) -> datasets.DatasetInfo:
        if self.config.schema == "source":
            features = datasets.Features(
                {
                    "image_path": datasets.Value("string"),
                    "label": datasets.ClassLabel(names=[i for i in range(111)]),
                }
            )
        elif self.config.schema == _SEACROWD_SCHEMA:
            features = schemas.image_text_features(label_names=[i for i in range(111)])

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

    def module_exists(self, module_name):
        try:
            __import__(module_name)
        except ImportError:
            return False
        else:
            return True

    def _split_generators(self, dl_manager: datasets.DownloadManager) -> List[datasets.SplitGenerator]:
        """Returns SplitGenerators."""
        # check if gdown is installed
        if self.module_exists("gdown"):
            import gdown
        else:
            raise ImportError("Please install `gdown` to enable downloading data from google drive.")

        # create custom data directory
        data_dir = Path.cwd() / "data" / "sleukrith_ocr"
        data_dir.mkdir(parents=True, exist_ok=True)

        # reliable google drive downloader
        data_paths = {}
        for key, value in _URLS["isolated-characters"].items():
            idx = value.rsplit("=", maxsplit=1)[-1]
            output = f"{data_dir}/{key}"
            data_paths[key] = Path(output)

            if not Path(output).exists():
                gdown.download(id=idx, output=output)
            else:
                print(f"File {output} already exists, skipping download.")

        return [
            datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                gen_kwargs={
                    "image_data": data_paths["images_train"],
                    "label_data": data_paths["labels_train"],
                    "split": "train",
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.TEST,
                gen_kwargs={
                    "image_data": data_paths["images_test"],
                    "label_data": data_paths["labels_test"],
                    "split": "test",
                },
            ),
        ]

    def _generate_examples(self, image_data: Path, label_data: Path, split: str) -> Tuple[int, Dict]:
        """Yields examples as (key, example) tuples."""
        # check if PIL is installed
        if self.module_exists("PIL"):
            from PIL import Image
        else:
            raise ImportError("Please install `pillow` to process images.")

        # load images
        with open(image_data, "rb") as file:
            # read and unpack the first 12 bytes for metadata
            width, height, nb_samples = struct.unpack(">iii", file.read(12))

            images = []
            for _ in range(nb_samples):
                # read and convert binary data to np array and reshape
                image_data = file.read(width * height)
                image = np.frombuffer(image_data, dtype=np.uint8).reshape((height, width))
                images.append(image)

        # save images and store path
        image_paths = []
        for i, image in enumerate(images):
            image_dir = Path.cwd() / "data" / "sleukrith_ocr" / split
            image_dir.mkdir(exist_ok=True)
            image_path = f"{image_dir}/image_{i}.png"

            if not Path(image_path).exists():
                Image.fromarray(image).save(image_path)

            assert Path(image_path).exists(), f"Image {image_path} not found."
            image_paths.append(image_path)

        # load labels
        with open(label_data, "rb") as file:
            # read and unpack the first 8 bytes for nb_classes and nb_samples
            nb_classes, nb_samples = struct.unpack(">ii", file.read(8))
            assert nb_samples == len(image_paths), "Number of labels do not match number of images."

            labels = []
            for _ in range(nb_samples):
                (label,) = struct.unpack(">i", file.read(4))
                assert 0 <= label < nb_classes, f"Label {label} out of bounds."
                labels.append(label)

        if self.config.schema == "source":
            for idx, example in enumerate(zip(image_paths, labels)):
                yield idx, {
                    "image_path": example[0],
                    "label": example[1],
                }

        elif self.config.schema == _SEACROWD_SCHEMA:
            for idx, example in enumerate(zip(image_paths, labels)):
                yield idx, {
                    "id": str(idx),
                    "image_paths": [example[0]],
                    "texts": None,
                    "metadata": {
                        "context": None,
                        "labels": [example[1]],
                    },
                }