💻 computer science

BlankSkip: Early-exit Object Detection onboard Nano-drones

This paper introduces BlankSkip, an adaptive early-exit object detection network designed for resource-constrained nano-drones that significantly improves inference throughput by skipping computation on empty frames with only a negligible drop in detection accuracy.

Original authors: Carlo Marra, Beatrice Alessandra Motetti, Alessio Burrello, Enrico Macii, Massimo Poncino, Daniele Jahier Pagliari

Published 2026-03-31

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Carlo Marra, Beatrice Alessandra Motetti, Alessio Burrello, Enrico Macii, Massimo Poncino, Daniele Jahier Pagliari

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are the pilot of a tiny, super-fast drone, no bigger than a dinner plate. Your job is to fly around a building, looking for lost items like water bottles or soda cans. But there's a catch: your drone is powered by a tiny battery and has a brain the size of a postage stamp. It's so weak that if it tries to "think" about every single picture it takes, it will run out of power before it finds anything, or it will move so slowly that it misses the objects entirely.

This is the problem the paper "BLANKSKIP" tries to solve.

The Problem: The Over-Thinker Drone

Currently, these tiny drones are like a student taking a very hard math test. No matter how easy the question is (or if there is no question at all), the student reads every single word, does the calculations, and writes an answer for every frame of video.

In the real world, most of the video a drone sees is just empty walls, the floor, or the sky. There are no bottles or cans there. But the drone's computer doesn't know that. It wastes its tiny amount of energy and time analyzing empty space, just to say, "Nope, nothing here." By the time it finishes looking at the empty space, it's too slow to catch the next object.

The Solution: The "Skip" Button

The authors created a system called BLANKSKIP. Think of it as giving the drone a "gut feeling" or a quick glance before it does the hard work.

Here is how it works, using a simple analogy:

Imagine you are a security guard at a museum.

The Old Way (Static Detection): Every time someone walks by, you stop them, ask for ID, check their pockets, scan their shoes, and search their bag, even if they are just a janitor with a mop. It takes forever, and you get tired.
The BLANKSKIP Way: You have a quick "sentry" standing at the door.
1. The Sentry (The Early Exit): As someone approaches, the sentry takes a quick look. If they see a janitor with a mop (an "empty" frame), they wave them through immediately. No search needed.
2. The Full Search (The Main Detector): If the sentry sees someone who might be a thief (an object of interest), then they call you over to do the full, detailed search.

How BLANKSKIP Works in the Drone

The Quick Glance: The drone's software has a tiny, super-fast helper attached to its main brain. This helper looks at the image and asks one simple question: "Is there anything interesting here, or is it just empty space?"
The Decision:
- If the answer is "Empty," the drone stops immediately. It saves all that energy and time. It doesn't even look for the bottle.
- If the answer is "Something is there," the drone proceeds to do the full, heavy-duty search to find exactly where the bottle is and what it is.

Why This is a Big Deal

The researchers tested this on a real tiny drone (the Crazyflie 2.1). Here is what happened:

Speed Boost: Because the drone stopped wasting time on empty pictures, it could process 24% more images per second. That's like going from a slow jog to a sprint.
Energy Saved: It didn't have to do the heavy lifting for 40% of the pictures it saw.
Accuracy: The "sentry" was very good at its job. It only made a tiny mistake (missing a bottle very rarely), but the speed gain was huge.

The "Magic" Behind the Scenes

The paper also talks about how they trained this system. They didn't just guess where to put the "sentry." They used a smart computer program (like a chef tasting a soup and adjusting the spices) to find the perfect spot in the drone's brain to attach this quick-check system. They found that putting it in the middle of the brain was the sweet spot: early enough to save time, but late enough to be smart enough to know what it's looking at.

The Bottom Line

BLANKSKIP is like teaching a tiny, exhausted drone to stop overthinking. Instead of analyzing every single pixel of every single photo, it learns to quickly spot the boring, empty ones and skip them. This allows the drone to fly faster, last longer on its battery, and actually find the things it's looking for without crashing or getting lost.

It turns a slow, clumsy robot into a nimble, efficient explorer.

1. Problem Statement

Deploying Deep Neural Networks (DNNs) for Object Detection (OD) on nano-drones (e.g., Bitcraze Crazyflie 2.1) is critical for autonomous flight but is severely hindered by extreme hardware constraints:

Resources: $\approx$ 10 MiB RAM, $\approx$ 1 W power budget, and low clock frequencies (hundreds of MHz).
Inefficiency of Static Models: Existing solutions use static computational graphs (e.g., MobileNet-SSD) that process every frame with the same intensity, regardless of content.
The "Empty Frame" Problem: In exploration scenarios, a significant fraction of video frames contain no objects of interest. Processing these "empty" frames wastes computational resources and increases latency, reducing the effective frame rate needed for real-time navigation and obstacle avoidance.
Gap in Literature: While Early-Exit (EE) mechanisms are well-studied for image classification, their application to dense object detection tasks on severely constrained edge devices remains largely unexplored.

2. Methodology: BLANKSKIP

The authors propose BLANKSKIP, an adaptive inference framework that leverages the sparsity of object presence to reduce average inference latency.

Core Concept

Instead of running the full detection pipeline on every frame, BLANKSKIP decomposes the task into two sequential sub-problems:

Binary Classification (Early Exit): A lightweight auxiliary branch attached to an intermediate layer of the backbone network determines if a frame is "empty" (no objects) or "non-empty."
Object Detection: The full detection head (SSD) is executed only if the frame is classified as "non-empty." If classified as "empty," inference stops immediately.

Architecture

Backbone: MobileNetV2 with SSD detection heads.
Early-Exit (EE) Branch: A lightweight module attached at an intermediate layer $\ell$ $ℓ$ . It consists of:
- Two $3\times3$ convolutional layers (with BatchNorm and ReLU6).
- Global Average Pooling (GAP).
- Two fully connected layers outputting a binary probability ( $P(c|x_\ell)$ ).
Decision Mechanism: If $P(\text{empty}) \geq \tau$ (confidence threshold), the system skips the remaining backbone layers and detection heads.

Training Strategy

Composite Loss: The network is trained end-to-end with a joint loss function:
$L_{total} = L_{loc} + L_{cls} + \lambda \cdot L_{EE}$
- $L_{loc}$ and $L_{cls}$ : Standard SSD localization and classification losses.
- $L_{EE}$ : Weighted binary cross-entropy for the early-exit branch.
Class Weights ( $w_0, w_1$ ): These allow explicit control over the trade-off between missed detections (false positives in the "empty" class) and computational savings (false negatives). Higher weight on $w_0$ prioritizes detection reliability; higher weight on $w_1$ prioritizes energy savings.
Hyperparameter Optimization (HPO): The authors use Bayesian Optimization (Tree-structured Parzen Estimator) to jointly optimize:
- The optimal layer $\ell$ for branch placement.
- Learning rates, batch sizes, and loss weights.
- The confidence threshold $\tau$ .
- Objective: Maximize a composite score balancing baseline mAP, computational savings, and EE branch accuracy.

Deployment

Quantization: Models are quantized to 8-bit integers using Quantization-Aware Training (QAT) to fit the GAP8 SoC (which lacks a Floating Point Unit).
Compiler: The open-source DORY compiler generates optimized C code for the 8-core parallel cluster of the GAP8 chip.

3. Key Contributions

Novel EE Mechanism for OD: Introduced BLANKSKIP, the first EE framework specifically designed for dense object detection on nano-drones, utilizing a simple auxiliary classification task to gate the detection pipeline.
Joint Optimization Framework: Formulated the selection of branch placement, training hyperparameters, and inference thresholds as a Bayesian HPO problem to find the optimal trade-off between accuracy and efficiency.
Real-World Validation: Successfully deployed the model on the Bitcraze Crazyflie 2.1 with the GAP8 AI-deck, demonstrating feasibility on actual hardware with strict power/memory limits.
Comprehensive Evaluation: Evaluated on two datasets:
- Himax EE: A nano-drone specific dataset (augmented with synthetic empty frames).
- Cityscapes: A complex urban dataset (processed via patching to fit memory), proving generalizability.

4. Experimental Results

Himax EE Dataset (Nano-drone specific)

Throughput: Achieved 1.86 FPS on the GAP8 chip, a 24% improvement over the static MobileNet-SSD baseline (1.50 FPS).
Accuracy: Maintained a Mean Average Precision (mAP) of 0.540, a negligible drop of only 0.015 (2.7%) compared to the static 1.0× baseline (0.555).
Efficiency:
- Skipped 39.8% of frames.
- Reduced average Multiply-Accumulate (MAC) operations by 22.5%.
- When an early exit occurred, the cost dropped by 57.9% compared to a full pass.
Optimal Placement: The 4th stage of the backbone (Layer 9) provided the best balance, offering sufficient semantic abstraction for accurate "empty" detection without incurring excessive branch computation costs.

Cityscapes Dataset (Generalization)

Performance: Achieved 0.204 mAP (vs. 0.229 static), a ~11% drop, while skipping 26.7% of image patches.
Efficiency: Reduced average MACs by 12.1%.
Insight: The lower skip rate and accuracy drop reflect the higher complexity and object density of urban scenes, yet the method still provided viable efficiency gains.

Real-World Simulation

Tested on raw video from a previous drone exploration study.
Found that 71.7% of frames were effectively empty.
The model identified these with 85.48% precision, resulting in a 37.7% throughput improvement (2.07 FPS vs. 1.50 FPS).

5. Significance

Enabling True Autonomy: By increasing the effective frame rate, BLANKSKIP allows nano-drones to react faster to dynamic environments, reducing the likelihood of "missing" objects during fast maneuvers.
Resource Liberation: The computational savings freed by skipping empty frames can be reallocated to other critical concurrent tasks (e.g., SLAM, path planning, obstacle avoidance) without requiring hardware upgrades.
Hardware Efficiency: Demonstrates that complex computer vision tasks can be run on ultra-low-power, memory-constrained microcontrollers (GAP8) through intelligent software adaptation (Early Exit) and quantization, rather than relying solely on model compression.
Scalability: The approach is not limited to nano-drones; it offers a generalizable strategy for improving inference efficiency on any edge device where input data contains significant redundancy or "empty" content.