Hugging Face's logo

Datasets:
liuchang666
/
KubriCount

Tasks:
Object Detection
Modalities:
Image
ArXiv:
Tags:
image
Synthetic
object-counting
visual-counting
multi-grained-counting
tar
License:
Dataset card Files
xet
 Community
1
KubriCount / README.md
nielsr's picture
nielsr HF Staff
Add task category, update license and add project links
c5ee9fd verified
preview code
|
raw
history blame
9.73 kB
metadata 
license: apache-2.0
pretty_name: KubriCount
task_categories:
  - object-detection
tags:
  - image
  - synthetic
  - object-counting
  - visual-counting
  - multi-grained-counting
  - tar
  - shards

KubriCount

Project Page | Paper | Code

KubriCount is a large-scale synthetic benchmark for multi-grained visual counting, built for the research project Count Anything at Any Granularity.

The dataset targets open-world counting settings where the intended counting granularity must be explicit. A query may ask for a specific identity, an attribute variant, a category, an instance type, or a broader concept. KubriCount provides controlled distractors and dense instance-level supervision for training and evaluation.

Companion generation pipeline code is available at Verg-Avesta/KubriCount.

The paper is available at arXiv.

The released dataset can be used directly and does not require running the generation pipeline.

Highlights

  • Five counting granularities: identity, attribute, category, instance type, and concept.
  • Controlled generalization splits for seen categories, unseen assets, and unseen categories.
  • Dense supervision including counts, center points, 2D boxes, masks, negative categories, and scene metadata.
  • Large scale: 110,507 released scenes/images, 198,702 annotation items/queries, 157 categories, about 7.3M annotated objects, and up to 250 objects per image.
  • Automatic data construction with controllable 3D synthesis, mask-conditioned image editing, and VLM-based quality filtering.

Dataset Statistics

Split Released scenes Annotation items / queries Purpose
train 99,639 179,140 Training split with seen categories.
testA 5,462 9,837 Evaluation split with unseen assets from training categories.
testB 5,406 9,725 Evaluation split with unseen categories.
Total 110,507 198,702

Levels 2-5 can yield two annotation items from one image by swapping the target and distractor groups. This is why the number of annotation items is larger than the number of released scenes.

Level Statistics

Level Train normal Train dense TestA TestB Total scenes
L1 16,179 3,959 1,087 1,087 22,312
L2 size 7,582 2,402 569 586 11,139
L2 color 8,043 2,135 600 602 11,380
L3 15,386 3,624 1,053 1,014 21,077
L4 16,493 4,186 1,081 1,081 22,841
L5 15,825 3,825 1,072 1,036 21,758
Total 79,508 20,131 5,462 5,406 110,507

Counting Levels

Each level defines a target set and, when applicable, a controlled distractor set that differs by one semantic factor.

Level Granularity Description
L1 Identity-level Count all visible target instances of a single object type.
L2 Attribute-level Count objects distinguished by size or color while excluding the other attribute variant.
L3 Category-level Count one category while excluding a different category.
L4 Instance-level Count one instance type while excluding another instance type from the same category.
L5 Concept-level Count a category or concept with multiple instance types and plausible distractors.

Generation Pipeline

KubriCount is generated in four stages:

  1. 3D asset curation: build a categorized 3D asset bank from labeled 3D datasets and controllable 3D generation.
  2. Prototype synthesis: use Kubric, PyBullet, and Blender to render controllable multi-object scenes with exact instance metadata.
  3. Consistent image editing: improve visual realism while preserving object topology and annotations.
  4. Automatic data filtering: reject samples with layout drift, count changes, identity corruption, background hallucination, or severe artifacts.

The tar shards in this release contain only scenes that passed the automatic quality filter. The intermediate PASS/FAIL files are not included.

Dataset Structure 

.
├── README.md
├── merged_train_metadata.json
├── merged_test_metadata.json
├── metadata/
│   ├── all_pass_scenes.jsonl
│   ├── train_pass_scenes.jsonl
│   ├── testA_pass_scenes.jsonl
│   ├── testB_pass_scenes.jsonl
│   └── shards.jsonl
├── shards/
│   ├── train/
│   │   ├── train-000000.tar
│   │   ├── train-000001.tar
│   │   └── ...
│   ├── testA/
│   │   ├── testA-000000.tar
│   │   └── testA-000001.tar
│   └── testB/
│       ├── testB-000000.tar
│       └── testB-000001.tar
├── train/
│   └── extracted_metadata.json
├── testA/
│   └── extracted_metadata.json
└── testB/
    └── extracted_metadata.json

Files Inside Each Scene

The image folders are stored inside tar shards. Each tar preserves the split/level/timestamp/scene structure:

train/level5/20260205_135900/scene_0431/edited_00000.png
train/level5/20260205_135900/scene_0431/metadata.json
train/level5/20260205_135900/scene_0431/rgba_00000.png
train/level5/20260205_135900/scene_0431/segmentation_00000.png

Typical scene files:

  • edited_00000.png: final edited image used by the benchmark.
  • rgba_00000.png: original rendered RGBA image before editing.
  • segmentation_00000.png: instance segmentation map.
  • metadata.json: scene-level generation metadata, including camera, asset, split, level, and object information.

Path Convention

All KubriCount image paths in the released annotation files are relative paths. For example:

testA/level1/20260205_132725/scene_0213/edited_00000.png

After extracting the tar shards into a local directory, resolve an image_id with:

from pathlib import Path

root = Path("./KubriCount_restored")
image_path = root / "testA/level1/20260205_132725/scene_0213/edited_00000.png"

Annotation Files

  • train/extracted_metadata.json, testA/extracted_metadata.json, testB/extracted_metadata.json: split-level KubriCount annotations.
  • merged_train_metadata.json: merged KubriCount training metadata.
  • merged_test_metadata.json: combined test metadata for testA and testB.
  • metadata/*_pass_scenes.jsonl: scene-to-shard manifests.
  • metadata/shards.jsonl: one record per tar shard.

A typical annotation item is:

{
  "image_id": "train/level1/20260205_132641/scene_0001/edited_00000.png",
  "count": 104,
  "box_examples_coordinates": [
    [[742, 933], [742, 1024], [850, 1024], [850, 933]],
    [[699, 782], [699, 888], [797, 888], [797, 782]]
  ],
  "points": [
    [796.0, 978.5],
    [748.0, 835.0]
  ],
  "H": 1024,
  "W": 1024,
  "category": "shoe",
  "metadata": {
    "level": 1,
    "split": "train",
    "config_file": "/kubric/config_gpt.json"
  },
  "negative_count": 0,
  "negative_category": "",
  "negative_box_examples_coordinates": [],
  "negative_points": []
}

Download 

from huggingface_hub import snapshot_download

snapshot_download(
    repo_id="liuchang666/KubriCount",
    repo_type="dataset",
    local_dir="./KubriCount",
)

Command line:

huggingface-cli download liuchang666/KubriCount \
  --repo-type dataset \
  --local-dir ./KubriCount

Restore the Folder Structure

Use the following script to extract the tar shards and copy the annotation JSON files to a restored directory:

from pathlib import Path
import shutil
import tarfile


repo_dir = Path("./KubriCount")
restore_dir = Path("./KubriCount_restored")
splits = ["train", "testA", "testB"]

restore_dir.mkdir(parents=True, exist_ok=True)


def safe_extract(tar, path):
    path = path.resolve()
    for member in tar.getmembers():
        target = (path / member.name).resolve()
        if path not in target.parents and target != path:
            raise RuntimeError(f"Unsafe path in tar: {member.name}")
    tar.extractall(path)


for tar_path in sorted((repo_dir / "shards").glob("*/*.tar")):
    print(f"Extracting {tar_path}")
    with tarfile.open(tar_path, "r") as tar:
        safe_extract(tar, restore_dir)

for p in repo_dir.glob("*.json"):
    shutil.copy2(p, restore_dir / p.name)

for split in splits:
    src_split_dir = repo_dir / split
    dst_split_dir = restore_dir / split
    dst_split_dir.mkdir(parents=True, exist_ok=True)
    for p in src_split_dir.glob("*.json"):
        shutil.copy2(p, dst_split_dir / p.name)

print(f"Restored dataset to: {restore_dir}")

Read Images Directly From Tar Shards 

from pathlib import Path
import tarfile


repo_dir = Path("./KubriCount")

for tar_path in sorted((repo_dir / "shards").glob("*/*.tar")):
    with tarfile.open(tar_path, "r") as tar:
        for member in tar:
            if member.isfile() and member.name.endswith(".png"):
                data = tar.extractfile(member).read()
                print(member.name, len(data))
                break

Citation

If you find this dataset useful, please cite:

@article{liu2026count,
  title={Count Anything at Any Granularity},
  author={Liu, Chang and Wu, Haoning and Xie, Weidi},
  journal={arXiv preprint arXiv:2605.10887},
  year={2026}
}

Acknowledgements

KubriCount builds on the Kubric data generation framework.

Contact

For questions, please contact liuchang666@sjtu.edu.cn.