4K-Aircraft-Detection

A Curated Aircraft-Detection Collection for 4K and Higher-Resolution Imagery

🤗 Hugging Face · 🟣 ModelScope · Dataset statistics · Source terms

English | 中文：Hugging Face · ModelScope 中文首页

Overview

4K-Aircraft-Detection is a curated research collection for aircraft detection in high-resolution aerial and satellite imagery. It integrates aircraft samples from DOTA, FAIR1M, and HRPlanes into a common, traceable detection release, with preserved image bytes, source-group splits, and both three-size and single-aircraft-class interfaces.

Version 1.0.0 contains 3,406 unique images and 41,955 training box records. All 42,007 original input annotation rows remain available as provenance. The release contributes the integration, duplicate review, documented box handling, split protocol, and usable data interfaces; the original imagery and annotations remain credited to their source authors.

“4K” identifies the collection's research focus, rather than a fixed size for every image. There are 1,036 images at exactly 3840 × 2160, 3,326 with a longest edge of at least 3,840 pixels, and 80 below that threshold. Dimensions vary up to 29200 × 27620. Images are not uniformly resized or upscaled, and this release is separate from any synthetic mosaic collection.

Dataset at a glance

Item	Version 1.0.0
Unique images	3,406
Training box records	41,955
Original input annotation rows retained	42,007
Source groups	2,370
Image sources after exact-byte deduplication	DOTA: 1,263; FAIR1M: 29; HRPlanes: 2,114
Exactly 3840 × 2160	1,036 images
Longest edge ≥ 3,840 pixels	3,326 images
Longest edge < 3,840 pixels	80 images
Largest image dimensions	29200 × 27620
Largest individual encoded PNG	Approximately 1.30 GB
Full-resolution storage	Original encoded image bytes, one image per Parquet row; image.path=null
Parquet payload	25,886,081,462 bytes across 91 shards
Browsing preview	Separate preview / sample configuration: 6 unboxed thumbnails, longest edge ≤ 1,280 pixels

Parquet size includes the packaged data; it is different from the original image-payload byte total. Per-shard sizes and SHA-256 checksums are listed in metadata/parquet_manifest.json. A large original image may occupy its own shard; it is not reduced to meet a shard-size target.

Three size labels, one semantic category

All objects are aircraft. The three class IDs retain the input collection's relative bounding-box-area attributes, not aircraft models or physical aircraft-size classes.

For the original, pre-clipping normalized YOLO width w and height h, let r = w × h:

Class ID	Label	Original relative-area rule
0	small_plane	r < 0.013015267062517454
1	middle_plane	0.013015267062517454 <= r < 0.04767318343391047
2	big_plane	r >= 0.04767318343391047

Class IDs remain unchanged when a training box is clipped to the image boundary. Both the original and clipped relative areas are provided, so a clipped box can fall into a different area interval while retaining its original class ID. These thresholds are not the COCO small/medium/large definitions. Cropping or padding changes the image canvas and may change the relative area.

A single-class plane=0 export uses the same images, boxes, and split membership. This supports aircraft localization without treating the size attributes as separate semantic categories.

Splits and duplicate handling

Parquet split	YOLO / manifest split	Images
train	train	2,384
validation	val	511
test	test	511
Total		3,406

The collection is re-split by complete source groups with seed 20261025, targeting a 70/15/15 image allocation. DOTA crops and resampled variants sharing a P-number stay together. HRPlanes groups use the complete original filename stem after removing repeated source prefixes; FAIR1M groups use the original image ID. Exact image SHA-256 matches connect groups even when their source IDs differ.

The resulting 2,370 groups have zero known source-ID-group overlap and zero exact-image-SHA-256 overlap across train, validation, and test. This is grouping by known original image IDs; it does not establish geographic independence between different IDs or eliminate all perceptual near-duplicates.

Six pairs of exact-byte duplicate images were consolidated. Their 52 corresponding alternative annotation rows describe the reviewed duplicate objects with slightly different coordinates. Training uses the complete label set of the lexicographically first input filename in each pair, rather than counting those alternative rows as additional objects. Every original row and the duplicate-review provenance remains available in metadata/original_annotation_rows.jsonl and metadata/deduplication_decisions.json.

Box handling and audit trail

The default training boxes are intersected with the image boundary. 2,479 box records were clipped, with no box discarded by that clipping step. The original class IDs are retained. Original coordinates, source label text, clipping flags, and per-edge changes remain accessible for reproducibility.

Image bytes are preserved from the audited input collection, without resizing or recompression. SHA-256 preservation relative to that input snapshot does not claim that every asset was independently compared with its original upstream archive.

File	Purpose
metadata/manifest.jsonl	Image identity, source group, original aliases, hashes, dimensions, and release split; uses val for validation
metadata/annotation_rows.jsonl	Training boxes, original geometry, source-row provenance, and clipping details
metadata/original_annotation_rows.jsonl	All 42,007 original input annotation rows, including duplicate alternatives
metadata/clipping_changes.jsonl	Changed-box records
metadata/split_mapping.jsonl	Original-to-release split mapping
metadata/parquet_manifest.json	Arrow features, shard inventory, byte counts, and checksums
CHANGELOG.md	Curation changes in this release

“Original” annotation fields refer to the pre-clipping integrated input collection. They should not be read as a claim that its labels are byte-identical to every upstream dataset's original annotation format.

Record format

Each row in default contains one full-resolution image and an objects structure with aligned lists, so object i is represented by the i-th value of each object field.

Field	Meaning
image_id, sample_id, file_name	Release image identity, stable sample identity, and retained filename
image	Hugging Face Image value with original bytes and a null path
width, height	Full-resolution image dimensions
source_dataset	ClassLabel: 0=DOTA, 1=FAIR1M, 2=HRPlanes
source_image_id, source_group_id	Original-image identifier and connected source group used for splitting
image_sha256, original_splits	Image checksum and original input split aliases
objects.id	Training annotation IDs
objects.category	ClassLabel IDs 0/1/2 for the three size attributes
objects.bbox, objects.area	Clipped COCO [x_min, y_min, width, height] in full-image pixels, and pixel area
objects.bbox_original	Pre-clipping COCO-style pixel coordinates
objects.yolo_bbox	Clipped normalized [center_x, center_y, width, height]
objects.yolo_bbox_original	Original pre-clipping normalized YOLO coordinates
objects.was_clipped	Whether clipping changed the box
objects.clipping_delta	Inward changes at [left, top, right, bottom], in pixels
objects.original_relative_area, objects.clipped_relative_area	Relative area before and after clipping

Load from Hugging Face

Install the data tools:

pip install -U datasets pyarrow huggingface_hub

Stream the full-resolution data as encoded bytes, without pixel decoding:

from datasets import Image, load_dataset

train = load_dataset(
    "RL-MIND/4K-Aircraft-Detection",
    "default",
    split="train",
    streaming=True,
)
train = train.cast_column("image", Image(decode=False))
row = next(iter(train))

print(row["file_name"], row["width"], row["height"])
print(len(row["image"]["bytes"]), row["image"]["path"])  # encoded bytes, None
print(len(row["objects"]["category"]))
print(row["objects"]["bbox"][:1])

streaming=True avoids downloading the complete collection before iteration, and decode=False avoids allocating the decoded pixel array. Reading a row still requires memory for its encoded image; the largest PNG alone is approximately 1.30 GB. Use the preview configuration for lightweight browsing. For reproducible experiments, add revision= with the exact dataset commit recorded for the run.

Download from ModelScope

Use the official dataset snapshot downloader, then read the local Parquet files with datasets:

pip install -U modelscope datasets pyarrow

from pathlib import Path
from modelscope.hub.snapshot_download import dataset_snapshot_download
from datasets import Image, load_dataset

root = Path(dataset_snapshot_download(
    dataset_id="RL-MIND/4K-Aircraft-Detection",
    local_dir="./4K-Aircraft-Detection",
))

files = {
    split: sorted(str(p) for p in (root / "data").glob(f"{split}-*.parquet"))
    for split in ("train", "validation", "test")
}
data = load_dataset("parquet", data_files=files, streaming=True)
train = data["train"].cast_column("image", Image(decode=False))
row = next(iter(train))
print(row["file_name"], len(row["objects"]["category"]))

The snapshot contains the full repository payload, so allow enough disk space for the Parquet files. The downloader's official implementation supports dataset snapshots; this example reads Parquet directly and does not assume platform-specific MsDataset decoding behavior.

Export YOLO or use COCO

The exporter writes the original encoded image bytes and the clipped training labels. It maps Parquet validation to YOLO val, creates a portable data.yaml, and requires a new or empty output directory.

After obtaining scripts/export_yolo.py, export the three size classes from Hugging Face:

python scripts/export_yolo.py \
  --repo-id RL-MIND/4K-Aircraft-Detection \
  --output ./aircraft-size3-yolo

For one aircraft class:

python scripts/export_yolo.py \
  --repo-id RL-MIND/4K-Aircraft-Detection \
  --output ./aircraft-plane-yolo \
  --single-class

For a downloaded ModelScope or Hugging Face snapshot:

python ./4K-Aircraft-Detection/scripts/export_yolo.py \
  --local-dir ./4K-Aircraft-Detection \
  --output ./aircraft-local-yolo

annotations/ includes COCO instances_train.json, instances_val.json, and instances_test.json, plus yolo-size3-labels.zip, yolo-plane-labels.zip, and original-labels.zip. The original-label archive retains the canonical pre-clipping input labels; the JSONL provenance additionally retains all alternative rows from the duplicate review.

Visual preview

The contact sheet uses resized examples with ground-truth boxes, provided only to illustrate the data. The separate preview / sample configuration contains six unboxed thumbnails with a longest edge of at most 1,280 pixels. Neither is a training or evaluation split, and the six preview rows are additional display records rather than part of the 3,406-image training inventory.

The dataset logo is an AI-generated decorative brand asset. It is not a satellite observation or a dataset sample.

Intended use and limits

This collection supports academic research on aircraft detection, high-resolution inference, tiling, and scale-aware evaluation. Report the release revision, split protocol, per-size results, and a merged single-aircraft-class result when comparing methods.

The source datasets have different imaging and annotation conventions. The three size attributes are imbalanced and depend on the original image canvas. Group-disjoint IDs and byte-level duplicate checks do not guarantee geographically separate sites or complete perceptual deduplication. This release does not establish new native image acquisitions, manually revalidated annotations, or any model-performance claim.

Sources and terms

license: other refers to source-specific academic research terms. DOTA retains its published academic-use restrictions, HRPlanes its CC BY-NC-ND 4.0 terms, and FAIR1M its CC BY-NC-SA 3.0 terms. The repository does not replace these with a blanket MIT, Apache, or commercial-use license. See THIRD_PARTY_NOTICES.md.

• DOTA: Xia et al., DOTA: A Large-scale Dataset for Object Detection in Aerial Images, CVPR 2018. Official project.
• HRPlanes: Bakırman and Sertel, A benchmark dataset for deep learning-based airplane detection: HRPlanes, 2023. DOI.
• FAIR1M: Sun et al., FAIR1M: A benchmark dataset for fine-grained object recognition in high-resolution remote sensing imagery, 2022. DOI.

Citation

Please cite both this curated release and the source datasets used in your experiment. Machine-readable citation metadata is provided in CITATION.cff.

@dataset{rlmind2026_4k_aircraft_detection,
  author  = {{RL-MIND}},
  title   = {4K-Aircraft-Detection},
  year    = {2026},
  version = {1.0.0},
  url     = {https://huggingface.co/datasets/RL-MIND/4K-Aircraft-Detection}
}