TinyPerson is released by its authors for research, without a separate data license. Its images are frames of web videos and web images whose rights stay with their owners. This packaging adds no rights.

TinyPerson

TinyPerson, the tiny-person detection benchmark, packed once with the official annotations kept whole, so it loads in one line and no data path has to be configured:

from datasets import load_dataset

ds = load_dataset("shijli/tinyperson")  # 794 train / 816 test

TinyPerson (Yu et al., WACV 2020) collects seaside and maritime scenes from web videos and images, mostly 1920 x 1080 and 3840 x 2160 frames, and annotates every person in them. The persons are tiny: the scored boxes have a median size (square root of the area) of 13 pixels in train and 15 in test, and about one in five is under 8 pixels. Each box is labelled a sea person or an earth person and flagged when it is an ignore region, an uncertain object, a logo, or in a dense image.

Splits

split	images	labeled / dense / pure background	boxes	official file
`train`	794	717 / 48 / 29	42197	`tiny_set_train_with_dense.json`
`test`	816	781 / 30 / 5	30454	`tiny_set_test_with_dense.json`

These are all the labelled images of the release. The benchmark files tiny_set_train.json (746 images) and tiny_set_test.json (786 images) are exactly these minus the dense images, with identical boxes, which the build checks. TinyPerson has no validation split.

id is the file stem (e.g. bb_V0032_I0001640) and file_name the official path under train/ or test/ (e.g. labeled_images/bb_V0032_I0001640.jpg), whose folder is the image's subset: labeled_images, labeled_dense_images or pure_bg_images. image_id is the official json id (train 0 to 793, test 794 to 1609), so predictions can be written straight into the official evaluation format.

Columns

column	type	meaning
`id`	string	the file stem
`file_name`	string	the official path under `train/` or `test/`
`image_id`	int32	the official json image id
`image`	image	the JPEG, bytes unchanged
`width`, `height`	int32	image size in pixels
`objects.category`	ClassLabel(2)	`0` sea_person, `1` earth_person (official ids 1 and 2)
`objects.bbox`	4 x float32	the official `[x, y, w, h]`, absolute pixels, top-left origin
`objects.ignore`	bool	a crowd, an ambiguous region or a reflection in the water
`objects.uncertain`	bool	cannot be told to be a person
`objects.logo`	bool	a watermark or logo region (always also `ignore`)
`objects.in_dense_image`	bool	the box is in a dense image (more than 220 boxes)

objects is a dict of parallel lists, the way datasets stores a sequence of structs:

r = ds["train"][0]
o = r["objects"]
for category, box, ignore, uncertain in zip(o["category"], o["bbox"], o["ignore"], o["uncertain"]):
    ...

The benchmark protocol

The official tiny-person detection task treats sea and earth persons as one class, scores only the boxes that are neither ignore nor uncertain as positives, treats ignore and uncertain boxes as regions where a detection is neither a true nor a false positive, and leaves the dense images out of both training and evaluation. With this dataset that is:

def benchmark(record):
    o = record["objects"]
    keep = [not d for d in o["in_dense_image"]]  # all False for a dense image
    positive = [k and not (i or u) for k, i, u in zip(keep, o["ignore"], o["uncertain"])]
    ignored = [k and (i or u) for k, i, u in zip(keep, o["ignore"], o["uncertain"])]
    return positive, ignored

ds = ds.filter(lambda r: not any(r["objects"]["in_dense_image"]))

Box counts in the non-dense images:

split	positive	ignore	uncertain
`train`	18433 (6318 sea, 12115 earth)	3369	3486
`test`	13687 (4939 sea, 8748 earth)	1989	2832

The metrics are AP and miss rate at IoU 0.5 (also 0.25 and 0.75), at most 200 detections per image, on the size ranges tiny [1, 20], tiny1 [1, 8], tiny2 [8, 12], tiny3 [12, 20] and small [20, 32], measured as the square root of the box area in pixels. A detection is matched to an ignored region by the fraction of the detection inside it, not by IoU. The reference implementation is tiny_benchmark/MyPackage/tools/evaluate/evaluate_tiny.py in the TinyBenchmark repository, run against annotations/task/tiny_set_test_all.json.

The annotations are the official ones, verbatim

Each split holds exactly as many boxes as the with-dense json assigns to its images, and every box is the json's own [x, y, w, h] with its category and four flags. Nothing is filtered. The pure-background images are kept with their boxes, all of which are ignore regions, and the three images without any box (1 train, 2 test) are kept too.

Three json fields are not packed because they carry no information. area is w * h of the box to floating point precision on every annotation, and iscrowd is 0 everywhere. segmentation is a polygon drawn on the box's own outline: on most boxes it is the four corners, and on 3 to 4 percent it adds a few points along the edges, every point inside the box and within 2 pixels of its boundary. All three were checked over every annotation of both splits before being dropped.

Two details of the official files are worth knowing:

Every ignore box carries category id 1 (sea_person), whatever it covers. The category of an ignore box means nothing.
The per-category table in the TinyBenchmark dataset README gives 26331 sea and 15867 earth boxes in train. In the json these are the counts of the earth (id 2) boxes and of the sea (id 1) boxes plus all ignore boxes, so the table has the two names the wrong way round. The json is right: drawn on the images, id 1 boxes are the persons in the water.

What is not included

The 759 unlabelled images (no_label_images/, 380 train and 379 test) from the same videos.
The erase_with_uncertain_dataset/ images, in which the ignore and uncertain regions are filled with their mean colour. That is a preprocessing of these images and boxes, and can be redone from them.
The corner/ annotation files, which tile each image into overlapping sub-images (e.g. 640 x 512) for training and testing. These too are derived from the boxes packed here.

How this was packed

The repository includes create_dataset.py, which produced these parquet files from the official tiny_set/ folder with train.tar.gz and test.tar.gz unpacked next to annotations/. Images are copied through byte for byte. Before pushing, the build was checked against the source: the benchmark files are the with-dense files minus the dense images, box for box; every split holds exactly as many boxes as the json assigns to its images; every recorded size matches the JPEG; and sampled records decode back to the same categories, boxes and flags as the json.

License and attribution

TinyPerson is released by its authors through the TinyBenchmark repository for research, without a separate data license. Its images are frames of web videos and web images whose rights stay with their owners. This packaging adds no rights: use it for non-commercial research and cite the original work.

@inproceedings{yu2020scale,
    title={Scale Match for Tiny Person Detection},
    author={Yu, Xuehui and Gong, Yuqi and Jiang, Nan and Ye, Qixiang and Han, Zhenjun},
    booktitle={IEEE Winter Conference on Applications of Computer Vision (WACV)},
    pages={1257--1265}, year={2020}
}

Downloads last month: 51

Total file size:

462 MB