Hugging Face's logo

Datasets:
Dhi-Technologies
/
amodal-counting-benchmark

Tasks:
Object Detection
Size:
n<1K
Tags:
computer-vision
object-counting
occlusion
uncertainty-quantification
calibration
conformal-prediction
License:
Dataset card Files
xet
 Community

Acknowledge the terms to access this dataset

This repository is publicly accessible, but you have to accept the conditions to access its files and content.

Access is granted for non-commercial research and evaluation use only. By requesting access you agree not to redistribute this dataset or any derivative data, to cite Dhi Technologies in any publication or output that uses it, and to obtain a separate commercial license via dhi-tech.com before any commercial use. Access requests are reviewed manually by Dhi Technologies.

Log in or Sign Up to review the conditions and access this dataset content.

Amodal Counting Benchmark

Product: amodal-counting, "count what detectors can't see": visibility-corrected object counting through crowds, clutter, and occlusion, reported as a calibrated interval rather than a bare point estimate.

This dataset is the exact evaluation population the product's own amodal bench command scores against: procedurally generated scenes with known ground-truth occupancy, a simulated detector with a known detectability curve, and the naive-vs-corrected accuracy each scene produces. It ships so anyone can re-run the scoring, not just read a claimed number.

Synthetic data, real-data validation in progress

Every scene here is procedurally generated (ground-truth boxes, occluders, and a simulated detector with a known detectability curve). It is built so every claim the product makes can be checked against exact ground truth, not to resemble any specific real camera or crowd. The detectability curve for each crowding level is calibrated on 60 held-in synthetic worlds and scored fresh on the 40 held-out scenes shipped in scenes.jsonl, so the table below is not computed on data the calibration saw. This dataset itself contains no real-world imagery.

What's in this dataset

  • scenes.jsonl (160 rows, about 178 KB): 40 scenes per occlusion-density level (crowding in {0.0, 0.3, 0.6, 0.8}), generated by the repo's own amodal.synth.generate_scenes with seed=2. Each row:
    {"crowding": 0.0, "image_size": [640, 480],
 "detections": [[x1, y1, x2, y2], ...],
 "occluders": [[x1, y1, x2, y2], ...],
 "true_count": 12, "detected_count": 7,
 "true_visibilities": [1.0, 0.73, ...], "seed": 200000}
    detections are what a simulated detector reports (it misses occluded objects per a logistic detectability curve); true_count and true_visibilities are ground truth, not predictions.
  • bench_results.json (about 1.5 KB): output of amodal.cli bench --seed 0, the fitted detectability curve plus naive-vs-corrected accuracy per crowding level (the source of the table below).

How to load it

Verified against the actual files in this repository (prints 160 scenes, 0.0 12 7, and 2.8 2.4):

import json
from huggingface_hub import hf_hub_download

repo_id = "Dhi-Technologies/amodal-counting-benchmark"
scenes_path = hf_hub_download(repo_id, "scenes.jsonl", repo_type="dataset")
bench_path = hf_hub_download(repo_id, "bench_results.json", repo_type="dataset")

scenes = [json.loads(line) for line in open(scenes_path)]
bench = json.load(open(bench_path))

print(len(scenes), "scenes")
print(scenes[0]["crowding"], scenes[0]["true_count"], scenes[0]["detected_count"])
print(bench["sweep"][0]["naive_mae"], bench["sweep"][0]["corrected_mae"])

No datasets library loader script ships here; this is plain JSON Lines and JSON, readable with the standard library once downloaded.

Measured result (from this repo, reproduced when this dataset was generated)

Naive count is the raw detector count. Corrected count is the visibility-corrected estimate. Coverage is how often the 90% calibrated interval actually contained the true count, over the 40 held-out scenes at that crowding level.

crowding naive MAE corrected MAE 90% CI coverage
0.0 2.8 2.4 0.90
0.3 2.6 1.97 0.90
0.6 2.85 2.34 0.975
0.8 3.73 2.46 0.975

Reproduce with: PYTHONPATH=src .venv/bin/python -m amodal.cli bench --seed 0

Schema notes

  • Boxes are [x1, y1, x2, y2] in pixels, image origin top-left.
  • true_visibilities is the ground-truth fraction of each true object NOT covered by occluders, other objects, or the frame border: the quantity the estimator has to recover from detections alone.
  • This is an evaluation-only population (no train/validation split ships here); the curve-fitting worlds used to calibrate the detectability model are generated on demand by the same amodal.synth module and are not included as static files.

Real-world evidence (attributed to the product repo, not re-run for this card)

The synthetic table above demonstrates the method works when its own generative assumptions hold; it is not a claim about real camera behavior. The product repository separately documents a real-data re-test on CrowdHuman validation data (a public pedestrian-detection benchmark, SAHI tiled YOLOv8s detector, 270 images, 6,809 ground-truth boxes, run on external GPU hardware). These numbers are read from the repo's own evidence/a4_realdata/RESULTS.md, not independently reproduced for this card:

  • One-directional occlusion correction did not beat naive counting on that real dataset: naive MAE 11.767 versus corrected MAE 22.475 (single-feature curve) or 28.228 (multivariate curve), with interval coverage around 39 to 41% against a 90% target.
  • A two-sided estimator (adding a fitted precision model) is reported as the first variant to beat naive counting on that data: MAE 11.767 down to 11.031, coverage 90.67% against a 90% target.
  • On the 20 single densest real scenes (up to 227 true people from as few as 20 to 30 raw detections), naive counting remains better and the estimator's own coverage flag drops to 50%, correctly signaling extrapolation rather than silently failing.

Method card, no trained weights

This product is pure Python (numpy/scipy) math, not a trained model. There are no weights to download: the "detector" here is a simulated detectability curve, and the correction is Horvitz-Thompson estimation with conformal interval calibration. The honest finding worth flagging: uncapped correction can be worse than naive counting when a few near-zero-probability detections dominate the variance (measured per-scene MAE 2.89 vs 2.63 naive at crowding 0.6 with min_p=0.1), which is why the weight cap is set by measurement, not taste. See the calibration deep-dive post.

Limitations

  • Synthetic only in this dataset: no real camera footage or real crowd imagery ships here.
  • Single generation seed (seed=2 for the scenes, seed=0 for the bench sweep): the table is a point estimate over 40 scenes per level, not averaged across multiple seeds.
  • The visibility signal is pure box geometry (coverage by occluders and other detections); it carries no learned appearance model of occlusion.
  • The one real-world comparison available (CrowdHuman, above) shows the naive one-directional correction can make counting worse, not better, when the underlying detector's error is a two-sided mix of misses and duplicate/artifact overcounts.

License

This dataset is released under CC BY-NC 4.0 (non-commercial). Access is gated and requires manual approval: it is provided for non-commercial research and evaluation only, redistribution is not permitted, and any publication or output using it should cite Dhi Technologies. Commercial use requires a separate agreement; contact dhi-tech.com.

Try it

Source & research context

Downloads last month
12
Total file size:
196 kB

Space using Dhi-Technologies/amodal-counting-benchmark 1

Collections including Dhi-Technologies/amodal-counting-benchmark