Initialize (#1)

* add files

* update poetry files

* update

* update README.md

* add settings for 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}/CGL-Dataset-v2 main

.gitignore

@@ -0,0 +1,178 @@
+# Created by https://www.toptal.com/developers/gitignore/api/python
+# Edit at https://www.toptal.com/developers/gitignore?templates=python
+
+*.tar.gz
+
+### 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

CGL-Dataset-v2.py

@@ -0,0 +1,605 @@
+import ast
+import json
+import os
+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
+import torch
+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 import tqdm
+
+logger = get_logger(__name__)
+
+JsonDict = Dict[str, Any]
+ImageId = int
+CategoryId = int
+AnnotationId = int
+Bbox = Tuple[float, float, float, float]
+
+
+_DESCRIPTION = """\
+CGL-Dataset V2 is a dataset for the task of automatic graphic layout design of advertising posters, containing 60,548 training samples and 1035 testing samples. It is an extension of CGL-Dataset.
+"""
+
+_CITATION = """\
+@inproceedings{li2023relation,
+  title={Relation-Aware Diffusion Model for Controllable Poster Layout Generation},
+  author={Li, Fengheng and Liu, An and Feng, Wei and Zhu, Honghe and Li, Yaoyu and Zhang, Zheng and Lv, Jingjing and Zhu, Xin and Shen, Junjie and Lin, Zhangang},
+  booktitle={Proceedings of the 32nd ACM international conference on information & knowledge management},
+  pages={1249--1258},
+  year={2023}
+}
+"""
+
+_HOMEPAGE = "https://github.com/liuan0803/RADM"
+
+_LICENSE = """\
+Unknown
+"""
+
+
+class UncompressedRLE(TypedDict):
+    counts: List[int]
+    size: Tuple[int, int]
+
+
+class CompressedRLE(TypedDict):
+    counts: bytes
+    size: Tuple[int, int]
+
+
+@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 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 VisualAnnotationData(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,
+    ) -> "VisualAnnotationData":
+        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"],
+        )
+
+
+@dataclass
+class UserSelectedValue(object):
+    name: str
+
+
+@dataclass
+class Point(object):
+    x: int
+    y: int
+
+
+@dataclass
+class TextData(object):
+    user_selected_value: UserSelectedValue
+    category_description: str
+    points: List[Point]
+
+    @classmethod
+    def from_dict(cls, json_dict: JsonDict) -> "TextData":
+        return cls(
+            user_selected_value=UserSelectedValue(**json_dict["userSelectedValue"]),
+            points=[Point(**p) for p in json_dict["points"]],
+            category_description=json_dict["categoryDesc"],
+        )
+
+
+class TextAnnotationData(object):
+    @classmethod
+    def from_dict(cls, *args, **kwargs):
+        raise NotImplementedError
+
+
+@dataclass
+class TextAnnotationTrainData(TextAnnotationData):
+    is_sample: bool
+    image: str
+    rotate: float
+    data: List[TextData]
+    pin: str
+
+    @property
+    def id_images(self) -> int:
+        # 'ali_anno_1/22.png' -> ['ali_anno_1', '22.png']
+        _, id_filename = self.image.split("/")
+        # 22.png -> ['22', '.png']
+        root, _ = os.path.splitext(id_filename)
+        return int(root)
+
+    @classmethod
+    def from_dict(cls, json_dict: JsonDict) -> "TextAnnotationTrainData":
+        text_data = [TextData.from_dict(d) for d in json_dict["data"]]
+        return cls(
+            is_sample=bool(int(json_dict["isSample"])),
+            image=json_dict["image"],
+            rotate=json_dict["rotate"],
+            pin=json_dict["pin"],
+            data=text_data,
+        )
+
+
+@dataclass
+class TextAnnotationTestData(TextAnnotationData):
+    image_filename: str
+    product_detail_highlighted_word: Optional[List[str]] = None
+    blc_text: Optional[List[str]] = None
+    adv_sellpoint: Optional[List[str]] = None
+
+    @classmethod
+    def from_dict(
+        cls, image_filename: str, json_dict: JsonDict
+    ) -> "TextAnnotationTestData":
+        return cls(
+            image_filename=image_filename,
+            product_detail_highlighted_word=json_dict.get("productDetailHighlightWord"),
+            blc_text=json_dict.get("blc_text"),
+            adv_sellpoint=json_dict.get("adv_sellpoint"),
+        )
+
+
+@dataclass
+class TextFeatureData(object):
+    feats: List[torch.Tensor]
+    num: Optional[int] = None
+    pos: Optional[List[Tuple[int, int, int, int]]] = None
+
+    def __post_init__(self):
+        if self.num is None:
+            self.num = len(self.feats)
+
+        assert self.num == len(self.feats)
+
+        if self.pos:
+            assert self.num == len(self.pos) == len(self.feats)
+
+
+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:
+    logger.info(f"Load from {image_path}")
+    return Image.open(image_path)
+
+
+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_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_train_texts_data(
+    txt_path: pathlib.Path,
+    image_dicts: List[JsonDict],
+    tqdm_desc: str = "Load text annotations for training",
+) -> Dict[ImageId, TextAnnotationTrainData]:
+    assert txt_path.stem == "train", txt_path
+
+    texts: Dict[ImageId, TextAnnotationTrainData] = {}
+    with txt_path.open("r") as rf:
+        for line in tqdm(rf, desc=tqdm_desc):
+            text_dict = ast.literal_eval(line)
+            text_data_ann = TextAnnotationTrainData.from_dict(text_dict)
+            image_dict = image_dicts[text_data_ann.id_images]
+            image_id = image_dict["id"]
+
+            if image_id in texts:
+                raise ValueError(f"Duplicate image id: {image_id}")
+
+            texts[image_id] = text_data_ann
+    return texts
+
+
+def _load_test_texts_data(
+    txt_path: pathlib.Path,
+    images: Dict[ImageId, ImageData],
+    tqdm_desc: str = "Load text annotations for test",
+) -> Dict[ImageId, TextAnnotationTestData]:
+    assert txt_path.stem == "test", txt_path
+    images_dict = {image.file_name: image for image in images.values()}
+
+    texts = {}
+    with txt_path.open("r") as rf:
+        for line in tqdm(rf, desc=tqdm_desc):
+            image_filename, json_str = line.split("\t")
+            text_dict = ast.literal_eval(json_str)
+            text_data_ann = TextAnnotationTestData.from_dict(image_filename, text_dict)
+
+            image_id = images_dict[image_filename].image_id
+            if image_id in texts:
+                raise ValueError(f"Duplicate image id: {image_id}")
+
+            texts[image_id] = text_data_ann
+    return texts
+
+
+def load_texts_data(
+    txt_path: pathlib.Path,
+    image_dicts: List[JsonDict],
+    images: Dict[ImageId, ImageData],
+):
+    if txt_path.stem == "train":
+        return _load_train_texts_data(
+            txt_path=txt_path,
+            image_dicts=image_dicts,
+        )
+    elif txt_path.stem == "test":
+        return _load_test_texts_data(
+            txt_path=txt_path,
+            images=images,
+        )
+    else:
+        raise ValueError(f"Unknown text file: {txt_path}")
+
+
+def load_annotation_data(
+    label_dicts: List[JsonDict],
+    images: Dict[ImageId, ImageData],
+    decode_rle: bool,
+    tqdm_desc: str = "Load annotation data",
+) -> Dict[ImageId, List[VisualAnnotationData]]:
+    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 = VisualAnnotationData.from_dict(
+            label_dict, images=images, decode_rle=decode_rle
+        )
+        labels[label_data.image_id].append(label_data)
+    return labels
+
+
+def load_text_features(
+    txt_feature_dir: pathlib.Path,
+    image_dicts: List[JsonDict],
+    tqdm_desc="Load text features",
+) -> Dict[ImageId, TextFeatureData]:
+    text_features = {}
+    for image_dict in tqdm(image_dicts):
+        image_filename = image_dict["file_name"]
+        root, _ = os.path.splitext(image_filename)
+        txt_feature_path = txt_feature_dir / f"{root}_feats.pth"
+
+        if not txt_feature_path.exists():
+            # logger.warning(f"Text feature file not found: {txt_feature_path}")
+            continue
+
+        txt_feature_dict = torch.load(
+            txt_feature_path, map_location=torch.device("cpu")
+        )
+        txt_feature_data = TextFeatureData(**txt_feature_dict)
+
+        image_id = image_dict["id"]
+        if image_id in text_features:
+            raise ValueError(f"Duplicate image id: {image_id}")
+
+        text_features[image_id] = txt_feature_data
+    return text_features
+
+
+@dataclass
+class CGLDatasetV2Config(ds.BuilderConfig):
+    decode_rle: bool = False
+    include_text_features: bool = False
+
+
+class CGLDatasetV2(ds.GeneratorBasedBuilder):
+    VERSION = ds.Version("1.0.0")
+    BUILDER_CONFIG_CLASS = CGLDatasetV2Config
+    BUILDER_CONFIGS = [
+        CGLDatasetV2Config(version=VERSION, description=_DESCRIPTION),
+    ]
+
+    def _info(self) -> ds.DatasetInfo:
+        segmentation_feature = (
+            ds.Image()
+            if self.config.decode_rle  # type: ignore
+            else {
+                "counts": ds.Value("binary"),
+                "size": ds.Sequence(ds.Value("int32")),
+            }
+        )
+        features = ds.Features(
+            {
+                "image_id": ds.Value("int64"),
+                "file_name": ds.Value("string"),
+                "width": ds.Value("int64"),
+                "height": ds.Value("int64"),
+                "image": ds.Image(),
+                "annotations": ds.Sequence(
+                    {
+                        "annotation_id": ds.Value("int64"),
+                        "area": ds.Value("int64"),
+                        "bbox": ds.Sequence(ds.Value("int64")),
+                        "category": {
+                            "category_id": ds.Value("int64"),
+                            "name": ds.Value("string"),
+                            "supercategory": ds.Value("string"),
+                        },
+                        "category_id": ds.Value("int64"),
+                        "image_id": ds.Value("int64"),
+                        "iscrowd": ds.Value("bool"),
+                        "segmentation": segmentation_feature,
+                    }
+                ),
+                "text_annotation": {
+                    "is_sample": ds.Value("bool"),
+                    "image": ds.Value("string"),
+                    "rotate": ds.Value("float32"),
+                    "pin": ds.Value("string"),
+                    "data": ds.Sequence(
+                        {
+                            "category_description": ds.Value("string"),
+                            "points": ds.Sequence(
+                                {"x": ds.Value("int64"), "y": ds.Value("int64")}
+                            ),
+                            "user_selected_value": {"name": ds.Value("string")},
+                        }
+                    ),
+                    "product_detail_highlighted_word": ds.Sequence(ds.Value("string")),
+                    "blc_text": ds.Sequence(ds.Value("string")),
+                    "adv_sellpoint": ds.Sequence(ds.Value("string")),
+                },
+                "text_feature": {
+                    "num": ds.Value("int64"),
+                    "pos": ds.Sequence(ds.Sequence(ds.Value("int64"))),
+                    "feats": ds.Sequence(ds.Sequence(ds.Sequence(ds.Value("float32")))),
+                },
+            }
+        )
+        return ds.DatasetInfo(
+            description=_DESCRIPTION,
+            citation=_CITATION,
+            homepage=_HOMEPAGE,
+            license=_LICENSE,
+            features=features,
+        )
+
+    def _split_generators(
+        self, dl_manager: ds.DownloadManager
+    ) -> List[ds.SplitGenerator]:
+        assert dl_manager.manual_dir is not None
+        base_dir_path = os.path.expanduser(dl_manager.manual_dir)
+
+        if not os.path.exists(base_dir_path):
+            raise FileNotFoundError()
+
+        base_dir_path = dl_manager.extract(base_dir_path)
+        assert isinstance(base_dir_path, str)
+
+        dir_path = pathlib.Path(base_dir_path) / "RADM_dataset"
+
+        ann_dir = dir_path / "annotations"
+        img_dir = dir_path / "images"
+        txt_dir = dir_path / "texts"
+        txt_feature_dir = dir_path / "text_features"
+
+        tng_ann_json_path = ann_dir / "train.json"
+        tst_ann_json_path = ann_dir / "test.json"
+
+        tng_img_dir = img_dir / "train"
+        tst_img_dir = img_dir / "test"
+
+        tng_img_json_path = tng_img_dir / "train.json"
+        tst_img_json_path = tst_img_dir / "test.json"
+
+        tng_txt_path = txt_dir / "train.txt"
+        tst_txt_path = txt_dir / "test.txt"
+
+        tng_txt_feature_dir = txt_feature_dir / "train"
+        tst_txt_feature_dir = txt_feature_dir / "test"
+
+        return [
+            ds.SplitGenerator(
+                name=ds.Split.TRAIN,  # type: ignore
+                gen_kwargs={
+                    "ann_json_path": tng_ann_json_path,
+                    "img_dir": tng_img_dir,
+                    "img_json_path": tng_img_json_path,
+                    "txt_path": tng_txt_path,
+                    "txt_feature_dir": tng_txt_feature_dir,
+                },
+            ),
+            ds.SplitGenerator(
+                name=ds.Split.TEST,  # type: ignore
+                gen_kwargs={
+                    "ann_json_path": tst_ann_json_path,
+                    "img_dir": tst_img_dir,
+                    "img_json_path": tst_img_json_path,
+                    "txt_path": tst_txt_path,
+                    "txt_feature_dir": tst_txt_feature_dir,
+                },
+            ),
+        ]
+
+    def _generate_examples(
+        self,
+        ann_json_path: pathlib.Path,
+        img_dir: pathlib.Path,
+        img_json_path: pathlib.Path,
+        txt_path: pathlib.Path,
+        txt_feature_dir: pathlib.Path,
+    ):
+        ann_json = load_json(ann_json_path)
+        images = load_images_data(image_dicts=ann_json["images"])
+        categories = load_categories_data(category_dicts=ann_json["categories"])
+
+        texts = load_texts_data(
+            txt_path=txt_path, image_dicts=ann_json["images"], images=images
+        )
+
+        text_features = (
+            load_text_features(
+                txt_feature_dir=txt_feature_dir, image_dicts=ann_json["images"]
+            )
+            if self.config.include_text_features  # type: ignore
+            else None
+        )
+
+        annotations = load_annotation_data(
+            label_dicts=ann_json["annotations"],
+            images=images,
+            decode_rle=self.config.decode_rle,  # type: ignore
+        )
+
+        for idx, image_id in enumerate(images.keys()):
+            image_data = images[image_id]
+            image_anns = annotations[image_id]
+
+            image = load_image(image_path=img_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)
+
+            text_data = texts.get(image_id)
+            example["text_annotation"] = asdict(text_data) if text_data else None  # type: ignore
+
+            if text_features:
+                text_feature = text_features.get(image_id)
+                example["text_feature"] = asdict(text_feature) if text_feature else None
+
+            yield idx, example

README.md

@@ -0,0 +1,267 @@
+---
+annotations_creators:
+- crowdsourced
+language:
+- zh
+language_creators:
+- found
+license:
+- unknown
+multilinguality:
+- monolingual
+pretty_name: CGL-Dataset v2
+size_categories: []
+source_datasets:
+- CGL-Dataset
+tags:
+- graphic design
+task_categories:
+- other
+task_ids: []
+---
+
+# Dataset Card for CGL-Dataset-v2
+
+[![CI](https://github.com/shunk031/huggingface-datasets_CGL-Dataset-v2/actions/workflows/ci.yaml/badge.svg)](https://github.com/shunk031/huggingface-datasets_CGL-Dataset-v2/actions/workflows/ci.yaml)
+[![Sync HF](https://github.com/shunk031/huggingface-datasets_CGL-Dataset-v2/actions/workflows/push_to_hub.yaml/badge.svg)](https://github.com/shunk031/huggingface-datasets_CGL-Dataset-v2/actions/workflows/push_to_hub.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/liuan0803/RADM
+- **Repository:** https://github.com/shunk031/huggingface-datasets_CGL-Dataset-v2
+- **Paper (Preprint):** https://arxiv.org/abs/2306.09086
+- **Paper (CIKM'23):** https://dl.acm.org/doi/10.1145/3583780.3615028
+
+### Dataset Summary
+
+CGL-Dataset V2 is a dataset for the task of automatic graphic layout design of advertising posters, containing 60,548 training samples and 1035 testing samples. It is an extension of CGL-Dataset.
+
+### Supported Tasks and Leaderboards
+
+[More Information Needed]
+
+<!-- For each of the tasks tagged for this dataset, give a brief description of the tag, metrics, and suggested models (with a link to their HuggingFace implementation if available). Give a similar description of tasks that were not covered by the structured tag set (repace the `task-category-tag` with an appropriate `other:other-task-name`).
+
+- `task-category-tag`: The dataset can be used to train a model for [TASK NAME], which consists in [TASK DESCRIPTION]. Success on this task is typically measured by achieving a *high/low* [metric name](https://huggingface.co/metrics/metric_name). The ([model name](https://huggingface.co/model_name) or [model class](https://huggingface.co/transformers/model_doc/model_class.html)) model currently achieves the following score. *[IF A LEADERBOARD IS AVAILABLE]:* This task has an active leaderboard which can be found at [leaderboard url]() and ranks models based on [metric name](https://huggingface.co/metrics/metric_name) while also reporting [other metric name](https://huggingface.co/metrics/other_metric_name). -->
+
+### Languages
+
+The language data in CGL-Dataset v2 is in Chinese ([BCP-47 zh](https://www.rfc-editor.org/info/bcp47)).
+
+## Dataset Structure
+
+### Data Instances
+
+To use CGL-Dataset v2 dataset, you need to download `RADM_dataset.tar.gz` that includes the poster image, text and text features via [JD Cloud](https://3.cn/10-dQKDKG) or [Google Drive](https://drive.google.com/file/d/1ezOzR7MX3MFFIfWgJmmEaqXn3iDFp2si/view?usp=sharing).
+Then place the downloaded files in the following structure and specify its path.
+
+```shell
+/path/to/datasets
+└── RADM_dataset.tar.gz
+```
+
+```python
+import datasets as ds
+
+dataset = ds.load_dataset(
+    path="shunk031/PosterErase",
+    data_dir="/path/to/datasets/RADM_dataset.tar.gz",
+    decode_rle=True, # True if Run-length Encoding (RLE) is to be decoded and converted to binary mask.
+    include_text_features=True, # True if RoBERTa-based text feature is to be loaded.
+)
+```
+
+### Data Fields
+
+[More Information Needed]
+
+<!-- List and describe the fields present in the dataset. Mention their data type, and whether they are used as input or output in any of the tasks the dataset currently supports. If the data has span indices, describe their attributes, such as whether they are at the character level or word level, whether they are contiguous or not, etc. If the datasets contains example IDs, state whether they have an inherent meaning, such as a mapping to other datasets or pointing to relationships between data points.
+
+- `example_field`: description of `example_field`
+
+Note that the descriptions can be initialized with the **Show Markdown Data Fields** output of the [Datasets Tagging app](https://huggingface.co/spaces/huggingface/datasets-tagging), you will then only need to refine the generated descriptions. -->
+
+### Data Splits
+
+[More Information Needed]
+
+<!-- Describe and name the splits in the dataset if there are more than one.
+
+Describe any criteria for splitting the data, if used. If there are differences between the splits (e.g. if the training annotations are machine-generated and the dev and test ones are created by humans, or if different numbers of annotators contributed to each example), describe them here.
+
+Provide the sizes of each split. As appropriate, provide any descriptive statistics for the features, such as average length.  For example:
+
+|                         | train | validation | test |
+|-------------------------|------:|-----------:|-----:|
+| Input Sentences         |       |            |      |
+| Average Sentence Length |       |            |      | -->
+
+## Dataset Creation
+
+### Curation Rationale
+
+[More Information Needed]
+
+<!-- What need motivated the creation of this dataset? What are some of the reasons underlying the major choices involved in putting it together? -->
+
+### Source Data
+
+[More Information Needed]
+
+<!-- This section describes the source data (e.g. news text and headlines, social media posts, translated sentences,...) -->
+
+#### Initial Data Collection and Normalization
+
+[More Information Needed]
+
+<!-- Describe the data collection process. Describe any criteria for data selection or filtering. List any key words or search terms used. If possible, include runtime information for the collection process.
+
+If data was collected from other pre-existing datasets, link to source here and to their [Hugging Face version](https://huggingface.co/datasets/dataset_name).
+
+If the data was modified or normalized after being collected (e.g. if the data is word-tokenized), describe the process and the tools used. -->
+
+#### Who are the source language producers?
+
+[More Information Needed]
+
+<!-- State whether the data was produced by humans or machine generated. Describe the people or systems who originally created the data.
+
+If available, include self-reported demographic or identity information for the source data creators, but avoid inferring this information. Instead state that this information is unknown. See [Larson 2017](https://www.aclweb.org/anthology/W17-1601.pdf) for using identity categories as a variables, particularly gender.
+
+Describe the conditions under which the data was created (for example, if the producers were crowdworkers, state what platform was used, or if the data was found, what website the data was found on). If compensation was provided, include that information here.
+
+Describe other people represented or mentioned in the data. Where possible, link to references for the information. -->
+
+### Annotations
+
+[More Information Needed]
+
+<!-- If the dataset contains annotations which are not part of the initial data collection, describe them in the following paragraphs. -->
+
+#### Annotation process
+
+[More Information Needed]
+
+<!-- If applicable, describe the annotation process and any tools used, or state otherwise. Describe the amount of data annotated, if not all. Describe or reference annotation guidelines provided to the annotators. If available, provide interannotator statistics. Describe any annotation validation processes. -->
+
+#### Who are the annotators?
+
+[More Information Needed]
+
+<!-- If annotations were collected for the source data (such as class labels or syntactic parses), state whether the annotations were produced by humans or machine generated.
+
+Describe the people or systems who originally created the annotations and their selection criteria if applicable.
+
+If available, include self-reported demographic or identity information for the annotators, but avoid inferring this information. Instead state that this information is unknown. See [Larson 2017](https://www.aclweb.org/anthology/W17-1601.pdf) for using identity categories as a variables, particularly gender.
+
+Describe the conditions under which the data was annotated (for example, if the annotators were crowdworkers, state what platform was used, or if the data was found, what website the data was found on). If compensation was provided, include that information here. -->
+
+### Personal and Sensitive Information
+
+[More Information Needed]
+
+<!-- State whether the dataset uses identity categories and, if so, how the information is used. Describe where this information comes from (i.e. self-reporting, collecting from profiles, inferring, etc.). See [Larson 2017](https://www.aclweb.org/anthology/W17-1601.pdf) for using identity categories as a variables, particularly gender. State whether the data is linked to individuals and whether those individuals can be identified in the dataset, either directly or indirectly (i.e., in combination with other data).
+
+State whether the dataset contains other data that might be considered sensitive (e.g., data that reveals racial or ethnic origins, sexual orientations, religious beliefs, political opinions or union memberships, or locations; financial or health data; biometric or genetic data; forms of government identification, such as social security numbers; criminal history).  
+
+If efforts were made to anonymize the data, describe the anonymization process. -->
+
+## Considerations for Using the Data
+
+### Social Impact of Dataset
+
+[More Information Needed]
+
+<!-- Please discuss some of the ways you believe the use of this dataset will impact society.
+
+The statement should include both positive outlooks, such as outlining how technologies developed through its use may improve people's lives, and discuss the accompanying risks. These risks may range from making important decisions more opaque to people who are affected by the technology, to reinforcing existing harmful biases (whose specifics should be discussed in the next section), among other considerations.
+
+Also describe in this section if the proposed dataset contains a low-resource or under-represented language. If this is the case or if this task has any impact on underserved communities, please elaborate here. -->
+
+### Discussion of Biases
+
+[More Information Needed]
+
+<!-- Provide descriptions of specific biases that are likely to be reflected in the data, and state whether any steps were taken to reduce their impact.
+
+For Wikipedia text, see for example [Dinan et al 2020 on biases in Wikipedia (esp. Table 1)](https://arxiv.org/abs/2005.00614), or [Blodgett et al 2020](https://www.aclweb.org/anthology/2020.acl-main.485/) for a more general discussion of the topic.
+
+If analyses have been run quantifying these biases, please add brief summaries and links to the studies here. -->
+
+### Other Known Limitations
+
+[More Information Needed]
+
+<!-- If studies of the datasets have outlined other limitations of the dataset, such as annotation artifacts, please outline and cite them here. -->
+
+## Additional Information
+
+### Dataset Curators
+
+[More Information Needed]
+
+<!-- List the people involved in collecting the dataset and their affiliation(s). If funding information is known, include it here. -->
+
+### Licensing Information
+
+[More Information Needed]
+
+<!-- Provide the license and link to the license webpage if available. -->
+
+### Citation Information
+
+<!-- Provide the [BibTex](http://www.bibtex.org/)-formatted reference for the dataset. For example:
+```
+@article{article_id,
+  author    = {Author List},
+  title     = {Dataset Paper Title},
+  journal   = {Publication Venue},
+  year      = {2525}
+}
+```
+
+If the dataset has a [DOI](https://www.doi.org/), please provide it here. -->
+
+```bibtex
+@inproceedings{li2023relation,
+  title={Relation-Aware Diffusion Model for Controllable Poster Layout Generation},
+  author={Li, Fengheng and Liu, An and Feng, Wei and Zhu, Honghe and Li, Yaoyu and Zhang, Zheng and Lv, Jingjing and Zhu, Xin and Shen, Junjie and Lin, Zhangang},
+  booktitle={Proceedings of the 32nd ACM international conference on information & knowledge management},
+  pages={1249--1258},
+  year={2023}
+}
+```
+
+### Contributions
+
+Thanks to [@liuan0803](https://github.com/liuan0803) for creating this dataset.

pyproject.toml

@@ -0,0 +1,26 @@
+[tool.poetry]
+name = "huggingface-datasets-cgl-dataset-v2"
+version = "0.1.0"
+description = ""
+authors = ["Shunsuke KITADA <shunsuke.kitada.0831@gmail.com>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.9"
+datasets = { extras = ["vision"], version = "^2.16.1" }
+pycocotools = "^2.0.7"
+torch = ">=1.0.0"
+
+[tool.poetry.group.dev.dependencies]
+ruff = "^0.1.11"
+black = "^23.12.1"
+isort = "^5.13.2"
+mypy = "^1.8.0"
+pytest = "^7.4.4"
+types-pillow = "^10.1.0.20240106"
+types-pycocotools = "^2.0.0.20240106"
+types-tqdm = "^4.66.0.20240106"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

tests/CGL-Dataset-v2_test.py

@@ -0,0 +1,53 @@
+import os
+
+import datasets as ds
+import pytest
+
+
+@pytest.fixture
+def dataset_path() -> str:
+    return "CGL-Dataset-v2.py"
+
+
+@pytest.fixture
+def data_dir() -> str:
+    return "RADM_dataset.tar.gz"
+
+
+@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=(
+        True,
+        False,
+    ),
+)
+@pytest.mark.parametrize(
+    argnames="include_text_features",
+    argvalues=(
+        True,
+        False,
+    ),
+)
+def test_load_dataset(
+    dataset_path: str,
+    data_dir: str,
+    include_text_features: bool,
+    decode_rle: bool,
+    expected_num_train: int = 60548,
+    expected_num_test: int = 1035,
+):
+    dataset = ds.load_dataset(
+        path=dataset_path,
+        data_dir=data_dir,
+        decode_rle=decode_rle,
+        include_text_features=include_text_features,
+    )
+    assert dataset["train"].num_rows == expected_num_train
+    assert dataset["test"].num_rows == expected_num_test