Official implementation of "Scale-Gated Gradient Bridging for Tiny Person Detection in Aerial Imagery" (submitted to IEEE Transactions on Geoscience and Remote Sensing).

Xiangqing Zhang, Yan Feng, Shun Zhang, Nan Wang, Guohua Lu, and Shaohui Mei

• [2026-07] Code release: SGGB / CDG / DAS training-time add-ons for Ultralytics YOLO26, with full reproduction scripts and 40+ training-run protocols.

End-to-end detectors such as YOLO26 abandon NMS by training a dense one-to-many (o2m) branch jointly with a sparse one-to-one (o2o) branch, yet the o2o head is architecturally forbidden from shaping the shared features it reads at inference. SGGB (Scale-Gated Gradient Bridging) opens a gradient-only path from the o2o branch back into the shared backbone/neck features — the forward computation graph is bit-identical to the baseline, and a single coefficient λ gates the bridge, so λ = 0 exactly reproduces the stock model. A cosine-decay schedule stabilizes the bridge across input resolutions. Two companion mechanisms (CDG: cross-head gradient deconfliction; DAS: disagreement-adaptive supervision) are included as honest negative-result ablations. On three aerial person-detection benchmarks (TinyPerson, AFO, HERIDAL), SGGB yields consistent gains that are largest on the tiniest objects (Tiny1 bin, h < 10 px: +0.020 AP50), and a gradient-flow probe verifies the intended 1.45–2.03× gradient amplification on shared features.

• Zero inference cost & bit-identical forward pass — SGGB touches only the backward graph; deployment models are unchanged.
• One-knob ablatable design — SGGB_LAMBDA=0 exactly reproduces baseline YOLO26 (verified by unit + integration tests).
• Gains concentrate where they matter — improvement is inversely proportional to object size (Tiny1 +0.020 > Tiny2 +0.016 > Small +0.008 > Medium +0.007 AP50).
• Honest negative results — CDG and DAS ablations included; everything is controlled by environment variables, no code edits needed.
• Full reproducibility — 40+ runs, ~260 GPU hours, 3 datasets × 3 seeds, Docker environment and suite scripts provided.

SGGB forks the shared feature pyramid at training time: the o2m branch consumes the original tensors, while the o2o branch consumes a λ-scaled view. Gradients from the o2o loss therefore flow back into the shared features through the bridge with strength λ, letting the inference-time head participate in representation learning. CDG optionally deconflicts the o2m/o2o gradient directions at the shared-feature level (β), and DAS reweights supervision by head disagreement (W).

Amplification ratio ‖∇_shared(λ = 0.5)‖ / ‖∇_shared(λ = 0)‖ measured on shared backbone/neck features: 1.45–2.03× across TinyPerson / AFO / HERIDAL.

├── ultralytics/              # YOLO26 source with SGGB/CDG/DAS add-ons
│   ├── nn/modules/head.py    #   ← SGGB bridge (λ gate, cosine/linear schedule)
│   ├── utils/cdg.py          #   ← CDG deconfliction (β) + DAS weight (W)
│   └── engine/trainer.py     #   ← epoch injection for λ schedules
├── tests/                    # unit + gradient-flow integration tests
│   ├── test_cdg_math.py
│   └── test_cdg_gradflow.py
├── configs/                  # dataset YAMLs (TinyPerson / AFO / HERIDAL)
├── docker/                   # reproducible training environment
├── docker-compose.yml
├── run_dataset_suite.sh      # one-command 3-seed × {baseline, SGGB} suite
├── gradflow_probe.py         # gradient amplification measurement
└── RESEARCH_CHANGES.md       # detailed changelog vs. stock Ultralytics

# Docker (recommended — matches the paper environment)
docker compose up -d
pip install -e .

# Or bare-metal
conda create -n sggb python=3.11 -y && conda activate sggb
pip install torch==2.4.0 --index-url https://download.pytorch.org/whl/cu124
pip install -e .

All mechanisms are controlled purely by environment variables — no code edits:

# Baseline (stock YOLO26 — all switches off)
export SGGB_LAMBDA=0.0 CDG_BETA=0.0 DAS_W=0.0

# SGGB with fixed λ
export SGGB_LAMBDA=0.5

# SGGB with cosine decay (recommended; used in the paper)
export SGGB_LAMBDA=0.5 SGGB_SCHEDULE=cosine

# Optional companions (active only when λ > 0)
export CDG_BETA=0.25     # cross-head gradient deconfliction
export DAS_W=0.1         # disagreement-adaptive supervision

# Train exactly like stock Ultralytics
yolo detect train model=yolo26s.pt data=configs/tinyperson.yaml imgsz=1280 epochs=100 batch=4

# 3-seed × {baseline, SGGB-cos} suite for one dataset (~6 runs)
bash run_dataset_suite.sh tinyperson configs/tinyperson.yaml yolo26s.pt 0
bash run_dataset_suite.sh afo        configs/afo.yaml        yolo26s.pt 0
bash run_dataset_suite.sh heridal    configs/heridal.yaml    yolo26s.pt 0

# Gradient-flow amplification probe
python gradflow_probe.py --weights runs/detect/<run>/weights/best.pt

# Sanity checks (all-switches-off == baseline)
pytest tests/test_cdg_math.py tests/test_cdg_gradflow.py

Protocol: YOLO26-S, COCO-pretrained, AdamW (lr = 0.002, cosine LR), 100 epochs, AMP off, batch 4 (2 at 1920), RTX 4090 24 GB.

@article{zhang2026sggb,
  title   = {Scale-Gated Gradient Bridging for Tiny Person Detection in Aerial Imagery},
  author  = {Zhang, Xiangqing and Feng, Yan and Zhang, Shun and Wang, Nan and Lu, Guohua and Mei, Shaohui},
  journal = {IEEE Transactions on Geoscience and Remote Sensing},
  year    = {2026},
  note    = {submitted}
}

This repository is built on Ultralytics YOLO26 (v8.4.80, editable install). It inherits the AGPL-3.0 license — see LICENSE. Datasets: TinyPerson, AFO, HERIDAL — please cite the original dataset papers when using them.