Initialize (#1)

* add files

* update types

* update

* update README.md

* update test

* add settings for CI

* update script

.github/workflows/ci.yaml

@@ -0,0 +1,49 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+    paths-ignore:
+      - "README.md"
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.9", "3.10"]
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          pip install -U pip setuptools wheel poetry
+          poetry install
+
+      - name: Format
+        run: |
+          poetry run black --check .
+
+      - name: Lint
+        run: |
+          poetry run ruff .
+
+      - name: Type check
+        run: |
+          poetry run mypy . \
+            --ignore-missing-imports \
+            --no-strict-optional \
+            --no-site-packages \
+            --cache-dir=/dev/null
+
+      - name: Run tests
+        run: |
+          poetry run pytest --color=yes -rf

.github/workflows/push_to_hub.yaml

@@ -0,0 +1,26 @@
+name: Sync to Hugging Face Hub
+
+on:
+  workflow_run:
+    workflows:
+      - CI
+    branches:
+      - main
+    types:
+      - completed
+
+jobs:
+  push_to_hub:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Push to Huggingface hub
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+          HF_USERNAME: ${{ secrets.HF_USERNAME }}
+        run: |
+          git fetch --unshallow
+          git push --force https://${HF_USERNAME}:${HF_TOKEN}@huggingface.co/datasets/${HF_USERNAME}/PubLayNet main

.gitignore

@@ -0,0 +1,176 @@
+# Created by https://www.toptal.com/developers/gitignore/api/python
+# Edit at https://www.toptal.com/developers/gitignore?templates=python
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json
+
+# End of https://www.toptal.com/developers/gitignore/api/python

PubLayNet.py

@@ -0,0 +1,396 @@
+import json
+import pathlib
+from collections import defaultdict
+from dataclasses import asdict, dataclass
+from typing import Any, Dict, List, Optional, Tuple, TypedDict, Union
+
+import datasets as ds
+import numpy as np
+from datasets.utils.logging import get_logger
+from PIL import Image
+from PIL.Image import Image as PilImage
+from pycocotools import mask as cocomask
+from tqdm.auto import tqdm
+
+logger = get_logger(__name__)
+
+JsonDict = Dict[str, Any]
+ImageId = int
+AnnotationId = int
+LicenseId = int
+CategoryId = int
+Bbox = Tuple[float, float, float, float]
+
+_DESCRIPTION = """\
+PubLayNet is a dataset for document layout analysis. It contains images of research papers and articles and annotations for various elements in a page such as "text", "list", "figure" etc in these research paper images. The dataset was obtained by automatically matching the XML representations and the content of over 1 million PDF articles that are publicly available on PubMed Central.
+"""
+
+_CITATION = """\
+@inproceedings{zhong2019publaynet,
+  title={Publaynet: largest dataset ever for document layout analysis},
+  author={Zhong, Xu and Tang, Jianbin and Yepes, Antonio Jimeno},
+  booktitle={2019 International Conference on Document Analysis and Recognition (ICDAR)},
+  pages={1015--1022},
+  year={2019},
+  organization={IEEE}
+}
+"""
+
+_HOMEPAGE = "https://developer.ibm.com/exchanges/data/all/publaynet/"
+
+_LICENSE = "CDLA-Permissive"
+
+_URL = "https://dax-cdn.cdn.appdomain.cloud/dax-publaynet/1.0.0/publaynet.tar.gz"
+
+
+class UncompressedRLE(TypedDict):
+    counts: List[int]
+    size: Tuple[int, int]
+
+
+class CompressedRLE(TypedDict):
+    counts: bytes
+    size: Tuple[int, int]
+
+
+@dataclass
+class CategoryData(object):
+    category_id: int
+    name: str
+    supercategory: str
+
+    @classmethod
+    def from_dict(cls, json_dict: JsonDict) -> "CategoryData":
+        return cls(
+            category_id=json_dict["id"],
+            name=json_dict["name"],
+            supercategory=json_dict["supercategory"],
+        )
+
+
+@dataclass
+class ImageData(object):
+    image_id: ImageId
+    file_name: str
+    width: int
+    height: int
+
+    @classmethod
+    def from_dict(cls, json_dict: JsonDict) -> "ImageData":
+        return cls(
+            image_id=json_dict["id"],
+            file_name=json_dict["file_name"],
+            width=json_dict["width"],
+            height=json_dict["height"],
+        )
+
+    @property
+    def shape(self) -> Tuple[int, int]:
+        return (self.height, self.width)
+
+
+@dataclass
+class AnnotationData(object):
+    annotation_id: AnnotationId
+    image_id: ImageId
+    segmentation: Union[np.ndarray, CompressedRLE]
+    area: float
+    iscrowd: bool
+    bbox: Bbox
+    category_id: int
+
+    @classmethod
+    def compress_rle(
+        cls,
+        segmentation: Union[List[List[float]], UncompressedRLE],
+        iscrowd: bool,
+        height: int,
+        width: int,
+    ) -> CompressedRLE:
+        if iscrowd:
+            rle = cocomask.frPyObjects(segmentation, h=height, w=width)
+        else:
+            rles = cocomask.frPyObjects(segmentation, h=height, w=width)
+            rle = cocomask.merge(rles)  # type: ignore
+
+        return rle  # type: ignore
+
+    @classmethod
+    def rle_segmentation_to_binary_mask(
+        cls, segmentation, iscrowd: bool, height: int, width: int
+    ) -> np.ndarray:
+        rle = cls.compress_rle(
+            segmentation=segmentation, iscrowd=iscrowd, height=height, width=width
+        )
+        return cocomask.decode(rle)  # type: ignore
+
+    @classmethod
+    def rle_segmentation_to_mask(
+        cls,
+        segmentation: Union[List[List[float]], UncompressedRLE],
+        iscrowd: bool,
+        height: int,
+        width: int,
+    ) -> np.ndarray:
+        binary_mask = cls.rle_segmentation_to_binary_mask(
+            segmentation=segmentation, iscrowd=iscrowd, height=height, width=width
+        )
+        return binary_mask * 255
+
+    @classmethod
+    def from_dict(
+        cls,
+        json_dict: JsonDict,
+        images: Dict[ImageId, ImageData],
+        decode_rle: bool,
+    ) -> "AnnotationData":
+        segmentation = json_dict["segmentation"]
+        image_id = json_dict["image_id"]
+        image_data = images[image_id]
+        iscrowd = bool(json_dict["iscrowd"])
+
+        segmentation_mask = (
+            cls.rle_segmentation_to_mask(
+                segmentation=segmentation,
+                iscrowd=iscrowd,
+                height=image_data.height,
+                width=image_data.width,
+            )
+            if decode_rle
+            else cls.compress_rle(
+                segmentation=segmentation,
+                iscrowd=iscrowd,
+                height=image_data.height,
+                width=image_data.width,
+            )
+        )
+        return cls(
+            annotation_id=json_dict["id"],
+            image_id=image_id,
+            segmentation=segmentation_mask,  # type: ignore
+            area=json_dict["area"],
+            iscrowd=iscrowd,
+            bbox=json_dict["bbox"],
+            category_id=json_dict["category_id"],
+        )
+
+
+def load_json(json_path: pathlib.Path) -> JsonDict:
+    logger.info(f"Load from {json_path}")
+    with json_path.open("r") as rf:
+        json_dict = json.load(rf)
+    return json_dict
+
+
+def load_image(image_path: pathlib.Path) -> PilImage:
+    return Image.open(image_path)
+
+
+def load_categories_data(
+    category_dicts: List[JsonDict],
+    tqdm_desc: str = "Load categories",
+) -> Dict[CategoryId, CategoryData]:
+    categories = {}
+    for category_dict in tqdm(category_dicts, desc=tqdm_desc):
+        category_data = CategoryData.from_dict(category_dict)
+        categories[category_data.category_id] = category_data
+    return categories
+
+
+def load_images_data(
+    image_dicts: List[JsonDict],
+    tqdm_desc="Load images",
+) -> Dict[ImageId, ImageData]:
+    images = {}
+    for image_dict in tqdm(image_dicts, desc=tqdm_desc):
+        image_data = ImageData.from_dict(image_dict)
+        images[image_data.image_id] = image_data
+    return images
+
+
+def load_annotation_data(
+    label_dicts: List[JsonDict],
+    images: Dict[ImageId, ImageData],
+    decode_rle: bool,
+    tqdm_desc: str = "Load label data",
+) -> Dict[ImageId, List[AnnotationData]]:
+    labels = defaultdict(list)
+    label_dicts = sorted(label_dicts, key=lambda d: d["image_id"])
+
+    for label_dict in tqdm(label_dicts, desc=tqdm_desc):
+        label_data = AnnotationData.from_dict(
+            label_dict, images=images, decode_rle=decode_rle
+        )
+        labels[label_data.image_id].append(label_data)
+    return labels
+
+
+def generate_train_val_examples(
+    annotations: Dict[ImageId, List[AnnotationData]],
+    image_dir: pathlib.Path,
+    images: Dict[ImageId, ImageData],
+    categories: Dict[CategoryId, CategoryData],
+):
+    for idx, image_id in enumerate(images.keys()):
+        image_data = images[image_id]
+        image_anns = annotations[image_id]
+
+        if len(image_anns) < 1:
+            logger.warning(f"No annotation found for image id: {image_id}.")
+            continue
+
+        image = load_image(image_path=image_dir / image_data.file_name)
+        example = asdict(image_data)
+        example["image"] = image
+
+        example["annotations"] = []
+        for ann in image_anns:
+            ann_dict = asdict(ann)
+            category = categories[ann.category_id]
+            ann_dict["category"] = asdict(category)
+            example["annotations"].append(ann_dict)
+
+        yield idx, example
+
+
+def generate_test_examples(image_dir: pathlib.Path):
+    image_paths = [f for f in image_dir.iterdir() if f.suffix == ".jpg"]
+    image_paths = sorted(image_paths)
+
+    for idx, image_path in enumerate(image_paths):
+        image = load_image(image_path=image_path)
+        image_width, image_height = image.size
+        image_data = ImageData(
+            image_id=idx,
+            file_name=image_path.name,
+            width=image_width,
+            height=image_height,
+        )
+        example = asdict(image_data)
+        example["image"] = image
+        example["annotations"] = []
+        yield idx, example
+
+
+@dataclass
+class PubLayNetConfig(ds.BuilderConfig):
+    decode_rle: bool = False
+
+
+class PubLayNetDataset(ds.GeneratorBasedBuilder):
+    VERSION = ds.Version("1.0.0")
+    BUILDER_CONFIG_CLASS = PubLayNetConfig
+    BUILDER_CONFIGS = [
+        PubLayNetConfig(
+            version=VERSION,
+            description="PubLayNet is a dataset for document layout analysis.",
+        )
+    ]
+
+    def _info(self) -> ds.DatasetInfo:
+        segmentation_feature = (
+            ds.Image()
+            if self.config.decode_rle
+            else {
+                "counts": ds.Value("binary"),
+                "size": ds.Sequence(ds.Value("int32")),
+            }
+        )
+        features = ds.Features(
+            {
+                "image_id": ds.Value("int32"),
+                "file_name": ds.Value("string"),
+                "width": ds.Value("int32"),
+                "height": ds.Value("int32"),
+                "image": ds.Image(),
+                "annotations": ds.Sequence(
+                    {
+                        "annotation_id": ds.Value("int32"),
+                        "area": ds.Value("float32"),
+                        "bbox": ds.Sequence(ds.Value("float32"), length=4),
+                        "category": {
+                            "category_id": ds.Value("int32"),
+                            "name": ds.ClassLabel(
+                                num_classes=5,
+                                names=["text", "title", "list", "table", "figure"],
+                            ),
+                            "supercategory": ds.Value("string"),
+                        },
+                        "category_id": ds.Value("int32"),
+                        "image_id": ds.Value("int32"),
+                        "iscrowd": ds.Value("bool"),
+                        "segmentation": segmentation_feature,
+                    }
+                ),
+            }
+        )
+        return ds.DatasetInfo(
+            description=_DESCRIPTION,
+            citation=_CITATION,
+            homepage=_HOMEPAGE,
+            license=_LICENSE,
+            features=features,
+        )
+
+    def _split_generators(self, dl_manager: ds.DownloadManager):
+        base_dir = dl_manager.download_and_extract(_URL)
+        publaynet_dir = pathlib.Path(base_dir) / "publaynet"
+
+        return [
+            ds.SplitGenerator(
+                name=ds.Split.TRAIN,
+                gen_kwargs={
+                    "image_dir": publaynet_dir / "train",
+                    "label_path": publaynet_dir / "train.json",
+                },
+            ),
+            ds.SplitGenerator(
+                name=ds.Split.VALIDATION,
+                gen_kwargs={
+                    "image_dir": publaynet_dir / "val",
+                    "label_path": publaynet_dir / "val.json",
+                },
+            ),
+            ds.SplitGenerator(
+                name=ds.Split.TEST,
+                gen_kwargs={
+                    "image_dir": publaynet_dir / "test",
+                },
+            ),
+        ]
+
+    def _generate_train_val_examples(
+        self, image_dir: pathlib.Path, label_path: pathlib.Path
+    ):
+        label_json = load_json(json_path=label_path)
+
+        images = load_images_data(image_dicts=label_json["images"])
+        categories = load_categories_data(category_dicts=label_json["categories"])
+
+        annotations = load_annotation_data(
+            label_dicts=label_json["annotations"],
+            images=images,
+            decode_rle=self.config.decode_rle,
+        )
+        yield from generate_train_val_examples(
+            annotations=annotations,
+            image_dir=image_dir,
+            images=images,
+            categories=categories,
+        )
+
+    def _generate_test_examples(self, image_dir: pathlib.Path):
+        yield from generate_test_examples(image_dir=image_dir)
+
+    def _generate_examples(
+        self, image_dir: pathlib.Path, label_path: Optional[pathlib.Path] = None
+    ):
+        if label_path is not None:
+            yield from self._generate_train_val_examples(
+                image_dir=image_dir,
+                label_path=label_path,
+            )
+        else:
+            yield from self._generate_test_examples(
+                image_dir=image_dir,
+            )

README.md

@@ -0,0 +1,189 @@
+---
+annotations_creators:
+- machine-generated
+language:
+- en
+language_creators:
+- found
+license:
+- cdla-permissive
+multilinguality:
+- monolingual
+pretty_name: PubLayNet
+size_categories: []
+source_datasets:
+- original
+tags:
+- graphic design
+- layout-generation
+task_categories:
+- image-classification
+- image-segmentation
+- image-to-text
+- question-answering
+- other
+- multiple-choice
+- token-classification
+- tabular-to-text
+- object-detection
+- table-question-answering
+- text-classification
+- table-to-text
+task_ids:
+- multi-label-image-classification
+- multi-class-image-classification
+- semantic-segmentation
+- image-captioning
+- extractive-qa
+- closed-domain-qa
+- multiple-choice-qa
+- named-entity-recognition
+---
+
+# Dataset Card for PubLayNet
+
+## Table of Contents
+- [Dataset Card Creation Guide](#dataset-card-creation-guide)
+  - [Table of Contents](#table-of-contents)
+  - [Dataset Description](#dataset-description)
+    - [Dataset Summary](#dataset-summary)
+    - [Supported Tasks and Leaderboards](#supported-tasks-and-leaderboards)
+    - [Languages](#languages)
+  - [Dataset Structure](#dataset-structure)
+    - [Data Instances](#data-instances)
+    - [Data Fields](#data-fields)
+    - [Data Splits](#data-splits)
+  - [Dataset Creation](#dataset-creation)
+    - [Curation Rationale](#curation-rationale)
+    - [Source Data](#source-data)
+      - [Initial Data Collection and Normalization](#initial-data-collection-and-normalization)
+      - [Who are the source language producers?](#who-are-the-source-language-producers)
+    - [Annotations](#annotations)
+      - [Annotation process](#annotation-process)
+      - [Who are the annotators?](#who-are-the-annotators)
+    - [Personal and Sensitive Information](#personal-and-sensitive-information)
+  - [Considerations for Using the Data](#considerations-for-using-the-data)
+    - [Social Impact of Dataset](#social-impact-of-dataset)
+    - [Discussion of Biases](#discussion-of-biases)
+    - [Other Known Limitations](#other-known-limitations)
+  - [Additional Information](#additional-information)
+    - [Dataset Curators](#dataset-curators)
+    - [Licensing Information](#licensing-information)
+    - [Citation Information](#citation-information)
+    - [Contributions](#contributions)
+
+## Dataset Description
+
+- **Homepage:** https://developer.ibm.com/exchanges/data/all/publaynet/
+- **Repository:** https://github.com/shunk031/huggingface-datasets_PubLayNet
+- **Paper (Preprint):** https://arxiv.org/abs/1908.07836
+- **Paper (ICDAR2019):** https://ieeexplore.ieee.org/document/8977963
+
+### Dataset Summary
+
+PubLayNet is a dataset for document layout analysis. It contains images of research papers and articles and annotations for various elements in a page such as "text", "list", "figure" etc in these research paper images. The dataset was obtained by automatically matching the XML representations and the content of over 1 million PDF articles that are publicly available on PubMed Central.
+
+### Supported Tasks and Leaderboards
+
+[More Information Needed]
+
+### Languages
+
+[More Information Needed]
+
+## Dataset Structure
+
+### Data Instances
+
+```python
+import datasets as ds
+
+dataset = ds.load_dataset(
+    path="shunk031/PubLayNet",
+    decode_rle=True, # True if Run-length Encoding (RLE) is to be decoded and converted to binary mask.
+)
+```
+
+### Data Fields
+
+[More Information Needed]
+
+### Data Splits
+
+[More Information Needed]
+
+## Dataset Creation
+
+### Curation Rationale
+
+[More Information Needed]
+
+### Source Data
+
+[More Information Needed]
+
+#### Initial Data Collection and Normalization
+
+[More Information Needed]
+
+#### Who are the source language producers?
+
+[More Information Needed]
+
+### Annotations
+
+[More Information Needed]
+
+#### Annotation process
+
+[More Information Needed]
+
+#### Who are the annotators?
+
+[More Information Needed]
+
+### Personal and Sensitive Information
+
+[More Information Needed]
+
+## Considerations for Using the Data
+
+### Social Impact of Dataset
+
+[More Information Needed]
+
+### Discussion of Biases
+
+[More Information Needed]
+
+### Other Known Limitations
+
+[More Information Needed]
+
+## Additional Information
+
+### Dataset Curators
+
+[More Information Needed]
+
+### Licensing Information
+
+- [CDLA-Permissive](https://cdla.io/permissive-1-0/)
+
+### Citation Information
+
+
+```bibtex
+@inproceedings{zhong2019publaynet,
+  title={Publaynet: largest dataset ever for document layout analysis},
+  author={Zhong, Xu and Tang, Jianbin and Yepes, Antonio Jimeno},
+  booktitle={2019 International Conference on Document Analysis and Recognition (ICDAR)},
+  pages={1015--1022},
+  year={2019},
+  organization={IEEE}
+}
+```
+
+### Contributions
+
+Thanks to [ibm-aur-nlp/PubLayNet](https://github.com/ibm-aur-nlp/PubLayNet) for creating this dataset.

pyproject.toml

@@ -0,0 +1,24 @@
+[tool.poetry]
+name = "huggingface-datasets-publaynet"
+version = "0.1.0"
+description = ""
+authors = ["Shunsuke KITADA <[email protected]>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.9"
+datasets = { extras = ["vision"], version = "^2.14.6" }
+pycocotools = "^2.0.7"
+
+[tool.poetry.group.dev.dependencies]
+ruff = "^0.1.1"
+black = "^23.10.1"
+mypy = "^1.6.1"
+pytest = "^7.4.2"
+types-pillow = "^10.1.0.0"
+types-pycocotools = "^2.0.0.4"
+types-tqdm = "^4.66.0.4"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

tests/PubLayNet_test.py

@@ -0,0 +1,37 @@
+import os
+
+import datasets as ds
+import pytest
+
+
+@pytest.fixture
+def dataset_path() -> str:
+    return "PubLayNet.py"
+
+
+@pytest.mark.skipif(
+    condition=bool(os.environ.get("CI", False)),
+    reason=(
+        "Because this loading script downloads a large dataset, "
+        "we will skip running it on CI."
+    ),
+)
+@pytest.mark.parametrize(
+    argnames=("decode_rle"),
+    argvalues=(False, True),
+)
+@pytest.mark.parametrize(
+    argnames=("expected_num_train", "expected_num_valid", "expected_num_test"),
+    argvalues=((335703, 11245, 11405),),
+)
+def test_load_dataset(
+    dataset_path: str,
+    decode_rle: bool,
+    expected_num_train: int,
+    expected_num_valid: int,
+    expected_num_test: int,
+):
+    dataset = ds.load_dataset(path=dataset_path, decode_rle=decode_rle)
+    assert dataset["train"].num_rows == expected_num_train
+    assert dataset["validation"].num_rows == expected_num_valid
+    assert dataset["test"].num_rows == expected_num_test