TakuNet: Lightweight CNN for UAV Emergencies

• TakuNet is a lightweight convolutional neural network tailored for embedded UAV platforms in emergency response, integrating early downsampling and dense connections.
• It utilizes depth-wise and grouped point-wise convolutions with FP16 optimization to reduce computational load (≈35.9M FLOPs) and a compact memory footprint (~37.7K parameters) while maintaining robust accuracy.
• Empirical benchmarks demonstrate that TakuNet sustains over 650 FPS on devices like the Jetson Orin Nano, making it highly suitable for low-power, high-throughput emergency applications.

TakuNet is a lightweight convolutional neural network architecture specifically devised for real-time inference on embedded unmanned aerial vehicle (UAV) platforms in emergency response settings. It employs early downsampling, depth-wise convolutions, grouped point-wise convolutions, and dense connections to minimize computational complexity and parameter count while maintaining competitive classification accuracy on aerial emergency datasets. TakuNet is optimized for 16-bit floating point (FP16) computation, significantly enhancing its throughput on embedded hardware accelerators such as NVIDIA Jetson boards. The architectural innovations enable TakuNet to deliver sustained inference speeds exceeding 650 frames per second (FPS) on a 15W Jetson Orin Nano, with a compact memory footprint and robust accuracy, making it suitable for deployment on resource-constrained, energy-limited UAV platforms (Rossi et al., 10 Jan 2025).

1. Design Motivations and Constraints

The central motivation for TakuNet arises from the unique operational constraints of UAV-based emergency response: limited onboard computational and memory resources, strict weight and power budgets, and the need for real-time decision support via aerial image classification. High-precision processors reduce UAV endurance due to power draw, while embedded accelerators impose further restrictions on network size and throughput. The architecture explicitly minimizes both parameter count (≈37,685 weights) and compute (≈35.9 million FLOPs), leveraging an early downsampling stem, depth-wise separable convolutions, dense connections, and FP16 support. These design choices enable real-time operation without substantial accuracy trade-offs, facilitating rapid hazard monitoring, search-and-rescue, and disaster assessment directly onboard UAVs (Rossi et al., 10 Jan 2025).

2. Architectural Composition

TakuNet’s macro-architecture comprises three primary components:

• Early downsampling stem: The input tensor $x \in \mathbb{R}^{H \times W \times 3}$ undergoes two layers: an initial $$\mathrm{Conv}_{3\times3,\,\text{stride}=2,\,\text{dilation}=2}$$ with ReLU6 and BatchNorm, followed by a depth-wise $\mathrm{DWConv}_{3\times3,\,\text{stride}=2}$ with ReLU6, producing a feature map of size $\tfrac{H}{4} \times \tfrac{W}{4}$ with 40 channels. This reduces computational demand for all subsequent layers by a factor of 16.
• Taku Blocks and dense connections: Four sequential stages, each composed of Taku Blocks (depth-wise 3×3 conv, possibly dilated, followed by grouped point-wise conv). The number of groups in point-wise convolutions is $$g = \lfloor (C_{\text{in}} + C_{\text{out}})/4 \rfloor$$. After each stage, dense connections are established by feature map concatenation:

$$G_s = \mathrm{concat}(I_s, F_s)\, \in\, \mathbb{R}^{H_s \times W_s \times (C'_s + C_s)}$$

promoting gradient flow and feature reuse, critical for fast convergence in compact models.

• Refiner and classifier: A depth-wise 3×3 convolution, BatchNorm, and adaptive average pooling collapse the final feature tensor to shape $1 \times 1 \times C_r$, which is fed to a linear layer for class logits.

All activations use ReLU6 to assure numerical stability in FP16. Global Response Normalization (GRN) is included after each pooling operation in Stages 1–4 but may be bypassed when targeting CPU-only devices to reduce latency (Rossi et al., 10 Jan 2025).

3. Efficiency Gains and Quantitative Analysis

TakuNet’s efficiency is driven by architectural strategies that optimize both memory and computation:

• Parameter and memory minimization: 37,685 parameters yield a model footprint of 0.15 MB in FP16 (0.30 MB in FP32).
• FP16 computation: Operations in FP16 halve memory requirements and double inference throughput relative to FP32, with measured accuracy loss remaining below 0.2%.
• Operation counts: Total complexity is ≈35.9 million FLOPs per inference.
• Convolutional cost savings: Standard, depth-wise, and point-wise convolutions have the following FLOP counts:

$$\begin{aligned} \mathrm{FLOPs}_{\mathrm{conv}} & = H_{\mathrm{out}} W_{\mathrm{out}} K^2 C_{\mathrm{in}} C_{\mathrm{out}} \ \mathrm{FLOPs}_{\mathrm{dw}} & = H_{\mathrm{out}} W_{\mathrm{out}} K^2 C_{\mathrm{in}} \ \mathrm{FLOPs}_{\mathrm{pw}} & = H_{\mathrm{out}} W_{\mathrm{out}} C_{\mathrm{in}} C_{\mathrm{out}} \end{aligned}$$

Grouped point-wise convolutions further decrease FLOPs as specified above.

This approach enables real-time classification while consuming minimal power and compute resources, allowing concurrent deployment of additional tasks such as object detection and tracking on the same embedded system (Rossi et al., 10 Jan 2025).

4. Training Strategy and Dataset Utilization

TakuNet is trained and validated on:

• AIDER: 5 classes, 6,433 images, 70/30 train/val split.
• AIDERv2: 4 classes, 16,723 images, 80/10/10 train/val/test split.

Input images are resized to $240 \times 240$. Data augmentation follows protocols from EmergencyNet, including color shifts, blurring, random crops, rotations, mirror flips, and shadow/illumination variations (applied with probabilities in 0.05–0.5).

Training parameters:

• Optimizer: RMSProp (decay=0.9, momentum=0.9)
• Initial learning rate: $\eta_0=10^{-3}$, step decay with $$\mathrm{Conv}_{3\times3,\,\text{stride}=2,\,\text{dilation}=2}$$0
• $$\mathrm{Conv}_{3\times3,\,\text{stride}=2,\,\text{dilation}=2}$$1 regularization: $$\mathrm{Conv}_{3\times3,\,\text{stride}=2,\,\text{dilation}=2}$$2
• Batch size: 64
• Epochs: 300
• Loss: Cross-entropy

Dense connections enable convergence in ≈200 epochs, a notably low value for lightweight networks (Rossi et al., 10 Jan 2025).

5. Empirical Performance and Benchmarks

Empirical evaluation demonstrates that TakuNet sustains near–state-of-the-art classification performance with a fraction of the resource demands of conventional models:

Model	Params	Size (MB)	FLOPs	AIDER F1 (%)	AIDERv2 F1 (%)
MobileNetV2	2.23 M	8.92	371.8 M	93.0	89.3
EfficientNet-B0	4.01 M	16.06	479.7 M	95.0	86.2
EmergencyNet	90.9 K	0.36	77.3 M	93.6	96.4
TinyEmergencyNet	39.3 K	0.16	36.3 M	89.5	93.4
TakuNet (FP16)	37.7 K	0.15	35.9 M	93.6	96.0
TakuNet (FP32)	37.7 K	0.15	35.9 M	93.8	95.8

On embedded platforms, TakuNet outperforms comparably sized models in throughput:

Device	Power	EmergencyNet FPS	TinyEmergencyNet FPS	TakuNet FPS
RPi 3 (5W)	5 W	6.7	10.8	7.0
RPi 4 (10W)	10 W	14.7	22.0	16.7
RPi 5 (10W)	10 W	43.3	59.8	62.1
Jetson Orin Nano	15 W	140.0	160.0	657.0
Jetson Orin Nano	7 W	–	–	564.0

TensorRT optimization on FP16 weights leads to a 4× speed-up over TinyEmergencyNet at equivalent TDP on the Jetson Orin Nano (Rossi et al., 10 Jan 2025).

6. Deployment Considerations and Limitations

TakuNet’s dense connectivity and use of dilated convolutions ensure stable generalization across diverse geospatial contexts (urban, rural, coastal). FP16 computation delivers double throughput with negligible accuracy loss on compliant GPUs; on CPUs without hardware FP16, FP32 achieves modestly reduced but adequate speeds. Operations such as Global Response Normalization (GRN) introduce latency on older ARM CPUs (e.g., RPi 3, RPi 4); deployment guides suggest bypassing GRN or replacing it with CPU-efficient alternatives for these cases. At 7W power consumption, Jetson Orin Nano exceeds 560 FPS, comfortably permitting real-time coreference with additional vision workloads (Rossi et al., 10 Jan 2025).

7. Availability and Implementation Notes

TakuNet’s full PyTorch implementation, along with training and TensorRT optimization utilities, is available at https://github.com/DanielRossi1/TakuNet. Key implementation details:

• Point-wise convolution group count: $$\mathrm{Conv}_{3\times3,\,\text{stride}=2,\,\text{dilation}=2}$$3
• ReLU6 is universally used for activation numeric stability
• GRN is present after pooling in the first four stages but can be bypassed for CPU optimization

This implementation enables reproducibility and facilitates further research and benchmarking in the context of low-power, real-time vision for UAV-driven emergency response (Rossi et al., 10 Jan 2025).