Initialize (#1)

* add files

* update script

* add README.md

* add CI

* update

.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}/PosterErase 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

PosterErase.py

@@ -0,0 +1,348 @@
+import json
+import os
+import pathlib
+from dataclasses import asdict, dataclass
+from typing import Any, Dict, List, Optional, Tuple
+
+import datasets as ds
+import pandas as pd
+from datasets.utils.logging import get_logger
+from PIL import Image
+from PIL.Image import Image as PilImage
+
+logger = get_logger(__name__)
+
+JsonDict = Dict[str, Any]
+
+
+_DESCRIPTION = """\
+PosterErase is a new dataset, which contains 60K high-resolution posters with texts and is more challenging for the text erasing task.
+"""
+
+_CITATION = """
+@inproceedings{jiang2022self,
+  title={Self-supervised text erasing with controllable image synthesis},
+  author={Jiang, Gangwei and Wang, Shiyao and Ge, Tiezheng and Jiang, Yuning and Wei, Ying and Lian, Defu},
+  booktitle={Proceedings of the 30th ACM International Conference on Multimedia},
+  pages={1973--1983},
+  year={2022}
+}
+"""
+
+_HOMEPAGE = "https://github.com/alimama-creative/Self-supervised-Text-Erasing"
+
+_LICENSE = """\
+The dataset is distributed under the CC BY-SA 4.0 license.
+"""
+
+_URL_BASE = (
+    "https://huggingface.co/datasets/shunk031/PosterErase-private/resolve/main/{}"
+)
+_ZIP_FILES = [f"erase_{i}.zip" for i in range(1, 7)]
+_URLS = [_URL_BASE.format(zip_file) for zip_file in _ZIP_FILES]
+
+
+def load_image(file_path: pathlib.Path) -> PilImage:
+    return Image.open(file_path)
+
+
+@dataclass
+class ColorData(object):
+    c1: Optional[int]
+    c2: Optional[int]
+    c3: Optional[int]
+
+    @classmethod
+    def from_string(cls, s: str) -> "ColorData":
+        assert isinstance(s, str)
+        cs = s.split(",")
+        if len(cs) == 3:
+            return ColorData(*list(map(lambda s: int(s), cs)))
+        elif len(cs) == 1:
+            return ColorData(*[None] * 3)
+        else:
+            raise ValueError(f"Invalid value: {cs}")
+
+
+@dataclass
+class TextData(object):
+    x: int
+    y: int
+    cs: List[ColorData]
+
+    @classmethod
+    def from_text_tuple(cls, text_tuple: Tuple[int, int, List[str]]) -> "TextData":
+        x, y, cs = text_tuple
+        assert isinstance(x, int) and isinstance(y, int)
+        return cls(x=x, y=y, cs=[ColorData.from_string(c) for c in cs])
+
+
+@dataclass
+class ObjectData(object):
+    text: Optional[str]
+    size: Optional[int]
+    direction: Optional[int]
+
+    @classmethod
+    def from_string(cls, s: str) -> "ObjectData":
+        assert isinstance(s, str)
+        ss = s.split(",")
+        if len(ss) == 3:
+            return cls(text=ss[0], size=int(ss[1]), direction=int(ss[2]))
+        elif len(ss) == 1:
+            return cls(*[None] * 3)
+        else:
+            raise ValueError(f"Invalid value: {ss}")
+
+
+@dataclass
+class PlaceData(object):
+    objs: List[ObjectData]
+    texts: List[List[TextData]]
+
+    @classmethod
+    def from_dict(cls, json_dict: JsonDict) -> "PlaceData":
+        objs = [
+            ObjectData.from_string(s) for s in json_dict["obj"].strip(";").split(";")
+        ]
+        texts = [
+            [TextData.from_text_tuple(tt) for tt in tts] for tts in json_dict["text"]
+        ]
+        return cls(objs=objs, texts=texts)
+
+
+@dataclass
+class MaskData(object):
+    x1: Optional[int]
+    x2: Optional[int]
+    y1: Optional[int]
+    y2: Optional[int]
+
+    @classmethod
+    def from_string(cls, s: str) -> "MaskData":
+        assert isinstance(s, str)
+        ss = s.split(",")
+
+        if len(ss) == 4:
+            return cls(*list(map(lambda s: int(s), ss)))
+        elif len(ss) == 1:
+            return cls(*[None] * 4)
+        else:
+            raise ValueError(f"Invalid value: {ss}")
+
+
+@dataclass
+class Annotation(object):
+    masks: List[MaskData]
+    place: Optional[PlaceData]
+
+    @classmethod
+    def from_dict(cls, json_dict: JsonDict) -> "Annotation":
+        masks = [
+            MaskData.from_string(s) for s in json_dict["mask"].strip(";").split(";")
+        ]
+
+        place_json = json_dict.get("place")
+        place = (
+            PlaceData.from_dict(json_dict["place"]) if place_json is not None else None
+        )
+        return cls(masks=masks, place=place)
+
+
+@dataclass
+class EraseData(object):
+    number: int
+    path: str
+    annotation: Annotation
+
+    @classmethod
+    def from_dict(cls, json_dict: JsonDict) -> "EraseData":
+        number = int(json_dict["number"])
+        path = json_dict["path"]
+        annotation = Annotation.from_dict(json_dict["json"])
+        return cls(number=number, path=path, annotation=annotation)
+
+
+def _load_annotation(file_path: pathlib.Path, columns: List[str]) -> pd.DataFrame:
+    df = pd.read_csv(file_path, delimiter="\t", names=columns)
+    df["json"] = df["json"].apply(json.loads)
+    return df
+
+
+def _load_tng_annotation(file_path: pathlib.Path) -> pd.DataFrame:
+    return _load_annotation(file_path=file_path, columns=["number", "path", "json"])
+
+
+def _load_val_annotation(file_path: pathlib.Path) -> pd.DataFrame:
+    return _load_annotation(
+        file_path=file_path, columns=["number", "path", "json", "gt_path"]
+    )
+
+
+def _load_tst_annotation(file_path: pathlib.Path) -> pd.DataFrame:
+    return _load_val_annotation(file_path=file_path)
+
+
+class PosterEraseDataset(ds.GeneratorBasedBuilder):
+    VERSION = ds.Version("1.0.0")
+    BUILDER_CONFIGS = [ds.BuilderConfig(version=VERSION, description=_DESCRIPTION)]
+
+    @property
+    def _manual_download_instructions(self) -> str:
+        return (
+            "To use PosterErase dataset, you need to download the dataset "
+            "via [Alibaba Cloud](https://tianchi.aliyun.com/dataset/134810)."
+        )
+
+    def _info(self) -> ds.DatasetInfo:
+        masks = ds.Sequence(
+            {
+                "x1": ds.Value("int32"),
+                "x2": ds.Value("int32"),
+                "y1": ds.Value("int32"),
+                "y2": ds.Value("int32"),
+            }
+        )
+        objs = ds.Sequence(
+            {
+                "text": ds.Value("string"),
+                "size": ds.Value("int32"),
+                "direction": ds.Value("int8"),
+            }
+        )
+        color = {
+            "c1": ds.Value("int32"),
+            "c2": ds.Value("int32"),
+            "c3": ds.Value("int32"),
+        }
+        text_feature = {
+            "x": ds.Value("int32"),
+            "y": ds.Value("int32"),
+            "cs": ds.Sequence(color),
+        }
+        texts = ds.Sequence(ds.Sequence(text_feature))
+        place = {"objs": objs, "texts": texts}
+        annotation = {"masks": masks, "place": place}
+        features = ds.Features(
+            {
+                "number": ds.Value("int32"),
+                "path": ds.Value("string"),
+                "image": ds.Image(),
+                "gt_image": ds.Image(),
+                "annotation": annotation,
+            }
+        )
+        return ds.DatasetInfo(
+            description=_DESCRIPTION,
+            citation=_CITATION,
+            homepage=_HOMEPAGE,
+            license=_LICENSE,
+            features=features,
+        )
+
+    def _download_from_hf(self, dl_manager: ds.DownloadManager) -> List[str]:
+        return dl_manager.download_and_extract(_URLS)
+
+    def _download_from_local(self, dl_manager: ds.DownloadManager) -> List[str]:
+        assert dl_manager.manual_dir is not None, dl_manager.manual_dir
+        dir_path = os.path.expanduser(dl_manager.manual_dir)
+
+        if not os.path.exists(dir_path):
+            raise FileNotFoundError(
+                "Make sure you have downloaded and placed the PosterErase dataset correctly. "
+                'Furthermore, you shoud check that a manual dir via `datasets.load_dataset("shunk031/PosterErase", data_dir=...)` '
+                "that include zip files from the downloaded files. "
+                f"Manual downloaded instructions: {self._manual_download_instructions}"
+            )
+
+        return dl_manager.extract(
+            path_or_paths=[os.path.join(dir_path, zip_file) for zip_file in _ZIP_FILES]
+        )
+
+    def _split_generators(
+        self, dl_manager: ds.DownloadManager
+    ) -> List[ds.SplitGenerator]:
+        base_dir_paths = (
+            self._download_from_hf(dl_manager)
+            if dl_manager.download_config.token
+            else self._download_from_local(dl_manager)
+        )
+        dir_paths = [pathlib.Path(dir_path) for dir_path in base_dir_paths]
+        dir_paths = [dir_path / f"erase_{i+1}" for i, dir_path in enumerate(dir_paths)]
+        dir_path, *sub_dir_paths = dir_paths
+
+        tng_df = _load_tng_annotation(dir_path / "train.txt")
+        val_df = _load_val_annotation(dir_path / "ps_valid.txt")
+        tst_df = _load_tst_annotation(dir_path / "ps_test.txt")
+
+        tng_image_files = {
+            f"{f.parent.name}/{f.name}": f for f in dir_path.glob("train/*.png")
+        }
+        val_image_files = {
+            f"{f.parent.name}/{f.name}": f for f in dir_path.glob("valid/*.png")
+        }
+        val_gt_image_files = {
+            f"{f.parent.name}/{f.name}": f for f in dir_path.glob("valid/*_gt.png")
+        }
+        tst_image_files = {
+            f"{f.parent.name}/{f.name}": f for f in dir_path.glob("test/*.png")
+        }
+        tst_gt_image_files = {
+            f"{f.parent.name}/{f.name}": f for f in dir_path.glob("test/*_gt.png")
+        }
+        for sub_dir_path in sub_dir_paths:
+            tng_image_files.update(
+                {
+                    f"{f.parent.name}/{f.name}": f
+                    for f in sub_dir_path.glob("train/*.png")
+                }
+            )
+        return [
+            ds.SplitGenerator(
+                name=ds.Split.TRAIN,
+                gen_kwargs={
+                    "annotation_df": tng_df,
+                    "image_files": tng_image_files,
+                },
+            ),
+            ds.SplitGenerator(
+                name=ds.Split.VALIDATION,
+                gen_kwargs={
+                    "annotation_df": val_df,
+                    "image_files": val_image_files,
+                    "gt_image_files": val_gt_image_files,
+                },
+            ),
+            ds.SplitGenerator(
+                name=ds.Split.TEST,
+                gen_kwargs={
+                    "annotation_df": tst_df,
+                    "image_files": tst_image_files,
+                    "gt_image_files": tst_gt_image_files,
+                },
+            ),
+        ]
+
+    def _generate_examples(
+        self,
+        annotation_df: pd.DataFrame,
+        image_files: Dict[str, pathlib.Path],
+        gt_image_files: Optional[Dict[str, pathlib.Path]] = None,
+    ):
+        ann_dicts = annotation_df.to_dict(orient="records")
+        for i, ann_dict in enumerate(ann_dicts):
+            image_path = image_files[ann_dict["path"]]
+            image = load_image(image_path)
+            erase_data = EraseData.from_dict(json_dict=ann_dict)
+
+            example = asdict(erase_data)
+            example["image"] = image
+
+            if gt_image_files is not None and "gt_path" in ann_dict:
+                gt_image_path = gt_image_files[ann_dict["gt_path"]]
+                gt_image = load_image(gt_image_path)
+                example["gt_image"] = gt_image
+            else:
+                example["gt_image"] = None
+
+            yield i, example

README.md

@@ -0,0 +1,184 @@
+---
+annotations_creators:
+- machine-generated
+language:
+- zh
+language_creators:
+- found
+license:
+- cc-by-sa-4.0
+multilinguality:
+- monolingual
+pretty_name: PosterErase
+size_categories: []
+source_datasets:
+- original
+tags:
+- graphic design
+task_categories:
+- other
+task_ids: []
+---
+
+# Dataset Card for PosterErase
+
+[![CI](https://github.com/shunk031/huggingface-datasets_PosterErase/actions/workflows/ci.yaml/badge.svg)](https://github.com/shunk031/huggingface-datasets_PosterErase/actions/workflows/ci.yaml)
+
+## 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://github.com/alimama-creative/Self-supervised-Text-Erasing
+- **Repository:** https://github.com/shunk031/huggingface-datasets_PosterErase
+- **Paper (Preprint):** https://arxiv.org/abs/2204.12743
+- **Paper (ACMMM2022):** https://dl.acm.org/doi/abs/10.1145/3503161.3547905
+
+### Dataset Summary
+
+### Supported Tasks and Leaderboards
+
+[More Information Needed]
+
+### Languages
+
+The language data in PKU-PosterLayout is in Chinese (BCP-47 zh).
+
+## Dataset Structure
+
+### Data Instances
+
+To use PosterErase dataset, you need to download the dataset via [Alibaba Cloud](https://tianchi.aliyun.com/dataset/134810).
+Then place the downloaded files in the following structure and specify its path.
+
+```
+/path/to/datasets
+├── erase_1.zip
+├── erase_2.zip
+├── erase_3.zip
+├── erase_4.zip
+├── erase_5.zip
+└── erase_6.zip
+```
+
+```python
+import datasets as ds
+
+dataset = ds.load_dataset(
+    path="shunk031/PosterErase",
+    data_dir="/path/to/datasets/",
+)
+```
+
+### 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
+
+You can find the following statement in [the license section](https://tianchi.aliyun.com/dataset/134810#license) of t[he dataset distribution location](https://tianchi.aliyun.com/dataset/134810).
+
+> The dataset is distributed under the CC BY-SA 4.0 license.
+
+However, the license setting on that page appears to be set to [CC-BY-SA-NC 4.0](http://creativecommons.org/licenses/by-sa/4.0/?spm=a2c22.12282016.0.0.7abc5a92qnyxdR).
+
+### Citation Information
+
+```bibtex
+@inproceedings{jiang2022self,
+  title={Self-supervised text erasing with controllable image synthesis},
+  author={Jiang, Gangwei and Wang, Shiyao and Ge, Tiezheng and Jiang, Yuning and Wei, Ying and Lian, Defu},
+  booktitle={Proceedings of the 30th ACM International Conference on Multimedia},
+  pages={1973--1983},
+  year={2022}
+}
+```
+
+### Contributions
+
+Thanks to [alimama-creative](https://github.com/alimama-creative) for creating this dataset.

pyproject.toml

@@ -0,0 +1,21 @@
+[tool.poetry]
+name = "huggingface-datasets-postererase"
+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"}
+
+
+[tool.poetry.group.dev.dependencies]
+ruff = "^0.1.4"
+black = "^23.10.1"
+mypy = "^1.6.1"
+pytest = "^7.4.3"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

tests/PosterErase_test.py

@@ -0,0 +1,33 @@
+import os
+
+import datasets as ds
+import pytest
+
+
+@pytest.fixture
+def dataset_path() -> str:
+    return "PosterErase.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=("expected_num_train", "expected_num_valid", "expected_num_test"),
+    argvalues=((58114, 148, 146),),
+)
+def test_load_dataset(
+    dataset_path: str,
+    expected_num_train: int,
+    expected_num_valid: int,
+    expected_num_test: int,
+):
+    dataset = ds.load_dataset(path=dataset_path, token=True)
+
+    assert dataset["train"].num_rows == expected_num_train
+    assert dataset["validation"].num_rows == expected_num_valid
+    assert dataset["test"].num_rows == expected_num_test