Add files using upload-large-folder tool

README.md

@@ -6,26 +6,58 @@ tags:
 - synthetic
 - object-counting
 - visual-counting
+- multi-grained-counting
+- tar
+- shards
 ---
 
 # KubriCount
 
-This dataset is a synthetic visual counting dataset.
+KubriCount is a large-scale synthetic benchmark for **multi-grained visual counting**, built for the research project **Count Anything at Any Granularity**.
 
-Each annotation item describes one image, the target category to count, positive instance boxes/points, and a negative category with corresponding negative boxes/points. The dataset has been filtered by `vlm_filter_results.json`; only scenes marked as `PASS` are included in the released tar shards.
+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 is generated with controllable 3D synthesis, mask-conditioned image editing, and VLM-based filtering, and provides dense instance-level supervision for training and evaluation.
 
-## Dataset structure
+## Highlights
+
+- **Five counting granularities**: identity, attribute, category, instance type, and concept.
+- **Controlled distractors** for testing prompt following under fine-grained distinctions.
+- **Dense supervision** including counts, center points, 2D boxes, negative categories, and scene-level metadata.
+- **Large scale**: 110,507 released scenes/images, 157 categories, about 7.3M annotated objects, and up to 250 objects per image.
+- **Generalization splits** for seen categories, unseen assets, and unseen categories.
+
+## Splits
+
+| Split | Released scenes | Purpose |
+| --- | ---: | --- |
+| `train` | 99,639 | Training split with seen categories. |
+| `testA` | 5,462 | Evaluation split with unseen assets from training categories. |
+| `testB` | 5,406 | Evaluation split with unseen categories. |
+
+The released tar shards contain only scenes that passed the automatic quality filter.
+
+## Counting Levels
+
+| Level | Granularity | Description |
+| --- | --- | --- |
+| L1 | Identity-level | Count all instances of a single object type. |
+| L2 | Attribute-level | Count objects distinguished by size or color. |
+| L3 | Category-level | Count one category while excluding another category. |
+| L4 | Instance-level | Count one instance type within the same category. |
+| L5 | Concept-level | Count a category or concept with multiple instance types and plausible distractors. |
+
+## Dataset Structure
 
 ```text
 .
 ├── 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
-│   └── dataset_stats.json
+│   └── shards.jsonl
 ├── shards/
 │   ├── train/
 │   │   ├── train-000000.tar
@@ -33,167 +65,114 @@ Each annotation item describes one image, the target category to count, positive
 │   │   └── ...
 │   ├── testA/
 │   │   ├── testA-000000.tar
-│   │   └── ...
+│   │   └── testA-000001.tar
 │   └── testB/
 │       ├── testB-000000.tar
-│       └── ...
+│       └── testB-000001.tar
 ├── train/
-│   ├── vlm_filter_results.json
-│   └── other train-level json files
+│   └── extracted_metadata.json
 ├── testA/
-│   ├── vlm_filter_results.json
-│   └── other testA-level json files
-├── testB/
-│   ├── vlm_filter_results.json
-│   └── other testB-level json files
-└── other dataset-level json files
+│   └── extracted_metadata.json
+└── testB/
+    └── extracted_metadata.json
 ```
 
-The scene folders are stored inside tar shards. Each tar file preserves the original split/level/timestamp/scene structure, for example:
+The image folders are stored inside tar shards. Each tar preserves the split/level/timestamp/scene structure:
 
 ```text
 train/level5/20260205_135900/scene_0431/edited_00000.png
-train/level5/20260205_135900/scene_0431/...
-testB/level1/20260205_132729/scene_0046/...
+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
 ```
 
-## Splits
-
-```text
-train, testA, testB
-```
-
-## Sharding information
+The release intentionally does **not** include `metadata/dataset_stats.json` or per-split `vlm_filter_results.json` files.
 
-- Scenes per shard: `5000`
-- Total PASS scenes: `110507`
-- Total files inside scenes: `442028`
-- Total shards: `24`
+## Path Convention
 
-Shard metadata is available in:
+All KubriCount image paths in the released annotation files are relative paths. For example:
 
 ```text
-metadata/shards.jsonl
+testA/level1/20260205_132725/scene_0213/edited_00000.png
 ```
 
-Scene-to-shard metadata is available in:
+After extracting the tar shards into a local directory, resolve an `image_id` with:
 
-```text
-metadata/all_pass_scenes.jsonl
-metadata/train_pass_scenes.jsonl
-metadata/testA_pass_scenes.jsonl
-metadata/testB_pass_scenes.jsonl
+```python
+from pathlib import Path
+
+root = Path("./KubriCount_restored")
+image_path = root / "testA/level1/20260205_132725/scene_0213/edited_00000.png"
 ```
 
-## Annotation format
+## 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:
 
 ```json
 {
-  "image_id": "/mnt/vision_user/changliu/kubric/count_data_best/train/level5/20260205_135900/scene_0431/edited_00000.png",
-  "count": 6,
+  "image_id": "train/level1/20260205_132641/scene_0001/edited_00000.png",
+  "count": 104,
   "box_examples_coordinates": [
-    [[[142, 656], [142, 1024], [494, 1024], [494, 656]]],
-    [[[230, 610], [230, 945], [632, 945], [632, 610]]]
+    [[742, 933], [742, 1024], [850, 1024], [850, 933]],
+    [[699, 782], [699, 888], [797, 888], [797, 782]]
   ],
   "points": [
-    [331.9403381347656, 895.3883056640625],
-    [438.8674011230469, 792.9484252929688]
+    [796.0, 978.5],
+    [748.0, 835.0]
   ],
   "H": 1024,
   "W": 1024,
-  "category": "trousers",
+  "category": "shoe",
   "metadata": {
-    "level": 5,
+    "level": 1,
     "split": "train",
     "config_file": "/kubric/config_gpt.json"
   },
-  "negative_count": 12,
-  "negative_category": "tie",
-  "negative_box_examples_coordinates": [
-    [[[591, 897], [591, 1008], [723, 1008], [723, 897]]]
-  ],
-  "negative_points": [
-    [655.068603515625, 951.5546875]
-  ]
+  "negative_count": 0,
+  "negative_category": "",
+  "negative_box_examples_coordinates": [],
+  "negative_points": []
 }
 ```
 
 Field meanings:
 
-- `image_id`: original image path used when generating the annotation.
+- `image_id`: relative path to the edited image after shard extraction.
 - `count`: number of target-category objects.
-- `category`: target category.
-- `box_examples_coordinates`: bounding boxes for target-category objects. Each box is represented by four corner points.
-- `points`: point annotations for target-category objects.
+- `category`: target category or target phrase.
+- `box_examples_coordinates`: target-object 2D boxes represented by four corner points.
+- `points`: target-object center points.
 - `H`, `W`: image height and width.
-- `metadata.level`: difficulty or generation level.
-- `metadata.split`: data split.
-- `negative_category`: category used as negative reference.
-- `negative_count`: number of negative-category objects.
-- `negative_box_examples_coordinates`: boxes for negative-category objects.
-- `negative_points`: point annotations for negative-category objects.
-
-The released image files are stored inside tar shards. To locate an image after extraction, use the split-relative part of `image_id`.
-
-For example, this original path:
-
-```text
-/mnt/vision_user/changliu/kubric/count_data_best/train/level5/20260205_135900/scene_0431/edited_00000.png
-```
-
-corresponds to the extracted path:
-
-```text
-train/level5/20260205_135900/scene_0431/edited_00000.png
-```
-
-## PASS filtering
-
-The original dataset was filtered using `vlm_filter_results.json`.
-
-Only scenes whose annotation value is `PASS` are included in the tar shards. For example:
-
-```json
-{
-  "level1/20260205_132729/scene_0046": "PASS"
-}
-```
+- `metadata.level`: counting granularity level.
+- `metadata.split`: dataset split.
+- `negative_category`: distractor category or phrase, when applicable.
+- `negative_count`: number of distractor objects.
+- `negative_box_examples_coordinates`: distractor-object 2D boxes.
+- `negative_points`: distractor-object center points.
 
-Scenes marked as `FAIL` are not included.
+## Manifest Format
 
-## Manifest format
-
-Each line in `metadata/all_pass_scenes.jsonl` describes one released scene. Example:
+Each line in `metadata/all_pass_scenes.jsonl` describes one released scene and where it is stored:
 
 ```json
 {
-  "split": "train",
-  "scene": "level1/20260205_132641/scene_0001",
-  "path_in_dataset": "train/level1/20260205_132641/scene_0001",
-  "shard": "shards/train/train-000000.tar",
+  "split": "testA",
+  "scene": "level1/20260205_132725/scene_0001",
+  "path_in_dataset": "testA/level1/20260205_132725/scene_0001",
+  "shard": "shards/testA/testA-000000.tar",
   "num_files": 4,
   "files": [
     {
-      "path": "train/level1/20260205_132641/scene_0001/edited_00000.png",
+      "path": "testA/level1/20260205_132725/scene_0001/edited_00000.png",
       "name": "edited_00000.png",
-      "size_bytes": 2168861
-    },
-    {
-      "path": "train/level1/20260205_132641/scene_0001/metadata.json",
-      "name": "metadata.json",
-      "size_bytes": 459308
-    },
-    {
-      "path": "train/level1/20260205_132641/scene_0001/rgba_00000.png",
-      "name": "rgba_00000.png",
-      "size_bytes": 1660110
-    },
-    {
-      "path": "train/level1/20260205_132641/scene_0001/segmentation_00000.png",
-      "name": "segmentation_00000.png",
-      "size_bytes": 61694
+      "size_bytes": 1562567
     }
   ]
 }
@@ -214,7 +193,7 @@ Important fields:
 from huggingface_hub import snapshot_download
 
 snapshot_download(
-    repo_id="YOUR_USERNAME_OR_ORG/KubriCount",
+    repo_id="liuchang666/KubriCount",
     repo_type="dataset",
     local_dir="./KubriCount",
 )
@@ -223,19 +202,19 @@ snapshot_download(
 Command line:
 
 ```bash
-huggingface-cli download YOUR_USERNAME_OR_ORG/KubriCount \
+huggingface-cli download liuchang666/KubriCount \
   --repo-type dataset \
   --local-dir ./KubriCount
 ```
 
-## Restore the original folder structure
+## Restore the Folder Structure
 
-Use the following script to extract all tar shards and copy the JSON files to the restored dataset directory.
+Use the following script to extract the tar shards and copy the annotation JSON files to a restored directory:
 
 ```python
 from pathlib import Path
-import tarfile
 import shutil
+import tarfile
 
 
 repo_dir = Path("./KubriCount")
@@ -246,37 +225,28 @@ restore_dir.mkdir(parents=True, exist_ok=True)
 
 
 def safe_extract(tar, path):
-    path = Path(path).resolve()
-
+    path = path.resolve()
     for member in tar.getmembers():
         target = (path / member.name).resolve()
-        if not str(target).startswith(str(path)):
+        if path not in target.parents and target != path:
             raise RuntimeError(f"Unsafe path in tar: {member.name}")
-
     tar.extractall(path)
 
 
-# Extract scene folders.
 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)
 
-
-# Copy dataset-level JSON files.
 for p in repo_dir.glob("*.json"):
     shutil.copy2(p, restore_dir / p.name)
 
-
-# Copy split-level JSON files.
 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)
-
-    if src_split_dir.exists():
-        for p in src_split_dir.glob("*.json"):
-            shutil.copy2(p, dst_split_dir / p.name)
+    for p in src_split_dir.glob("*.json"):
+        shutil.copy2(p, dst_split_dir / p.name)
 
 print(f"Restored dataset to: {restore_dir}")
 ```
@@ -286,58 +256,19 @@ After extraction:
 ```text
 KubriCount_restored/
 ├── train/
-│   ├── vlm_filter_results.json
+│   ├── extracted_metadata.json
 │   └── level1/
-│   └── level2/
-│   └── ...
 ├── testA/
-│   ├── vlm_filter_results.json
+│   ├── extracted_metadata.json
 │   └── level1/
-│   └── ...
 ├── testB/
-│   ├── vlm_filter_results.json
+│   ├── extracted_metadata.json
 │   └── level1/
-│   └── ...
-└── dataset-level json files
+├── merged_train_metadata.json
+└── merged_test_metadata.json
 ```
 
-## Resolve `image_id` to a local extracted image path
-
-Some annotation files may contain absolute original paths in `image_id`. After extraction, convert them to local paths as follows:
-
-```python
-from pathlib import Path
-
-
-def resolve_image_id(image_id, restored_root):
-    restored_root = Path(restored_root)
-
-    parts = Path(image_id).parts
-
-    for split in ["train", "testA", "testB"]:
-        if split in parts:
-            idx = parts.index(split)
-            rel_path = Path(*parts[idx:])
-            return restored_root / rel_path
-
-    raise ValueError(f"Cannot find split name in image_id: {image_id}")
-
-
-image_id = "/mnt/vision_user/changliu/kubric/count_data_best/train/level5/20260205_135900/scene_0431/edited_00000.png"
-local_path = resolve_image_id(image_id, "./KubriCount_restored")
-
-print(local_path)
-```
-
-Output:
-
-```text
-KubriCount_restored/train/level5/20260205_135900/scene_0431/edited_00000.png
-```
-
-## Read images directly from tar shards
-
-If you do not want to extract the full dataset, you can read files directly from tar shards.
+## Read Images Directly From Tar Shards
 
 ```python
 from pathlib import Path
@@ -349,26 +280,18 @@ 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 not member.isfile():
-                continue
-
-            if member.name.endswith(".png") or member.name.endswith(".jpg") or member.name.endswith(".jpeg"):
-                f = tar.extractfile(member)
-                data = f.read()
+            if member.isfile() and member.name.endswith(".png"):
+                data = tar.extractfile(member).read()
                 print(member.name, len(data))
                 break
 ```
 
-To find which shard contains a specific scene, use:
-
-```text
-metadata/all_pass_scenes.jsonl
-```
+To find the shard for a specific scene, use `metadata/all_pass_scenes.jsonl`.
 
-## Citation
+## Related Project
 
-Coming soon.
+Research project: **Count Anything at Any Granularity**.
 
 ## Contact
 
-If you have any questions, please feel free to contact liuchang666@sjtu.edu.cn.
+For questions, please contact liuchang666@sjtu.edu.cn.

merged_train_metadata.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4ec433a1a8ecc0c6301b1d98a51fd0523b20bc8736cffcb88466ac51aa4ebb83
-size 3672614873
+oid sha256:4ef4eb4940054be554bcc39697cb8778323daca44755630ae7522af017b2f3cc
+size 3656119857