ESCFM-YOLO: Lightweight Dual-Stream Architecture for Real-Time Small-Scale Fire Smoke Detection on Edge Devices

Abstract

Early detection of small-scale fires is crucial for minimizing damage and enabling rapid emergency response. While recent deep learning-based fire detection systems have achieved high accuracy, they still face three key challenges: (1) limited deployability in resource-constrained edge environments due to high computational costs, (2) performance degradation caused by feature interference when jointly learning flame and smoke features in a single backbone, and (3) low sensitivity to small flames and thin smoke in the initial stages. To address these issues, we propose a lightweight dual-stream fire detection architecture based on YOLOv5n, which learns flame and smoke features separately to improve both accuracy and efficiency under strict edge constraints. The proposed method integrates two specialized attention modules: ESCFM++, which enhances spatial and channel discrimination for sharp boundaries and local flame structures (flame), and ESCFM-RS, which captures low-contrast, diffuse smoke patterns through depthwise convolutions and residual scaling (smoke). On the D-Fire dataset, the flame detector achieved 74.5% mAP@50 with only 1.89 M parameters, while the smoke detector achieved 89.2% mAP@50. When deployed on an NVIDIA Jetson Xavier NX (NVIDIA Corporation, Santa Clara, CA, USA)., the system achieved 59.7 FPS (single-stream) and 28.3 FPS (dual-tream) with GPU utilization below 90% and power consumption under 17 W. Under identical on-device conditions, it outperforms YOLOv9t and YOLOv12n by 36–62% in FPS and 0.7–2.0% in detection accuracy. We further validate deployment via outdoor day/night long-range live-stream tests on Jetson using our flame detector, showing reliable capture of small, distant flames that appear as tiny cues on the screen, particularly in challenging daytime scenes. These results demonstrate overall that modality-specific stream specialization and ESCFM attention reduce feature interference while improving detection accuracy and computational efficiency for real-time edge-device fire monitoring.

1. Introduction

Fire is among the most destructive hazards in human history, causing substantial loss of life and property. Its severity arises from rapid spread: indoor fires can escalate quickly due to complex building layouts and high occupant density, whereas outdoor fires propagate over large areas under the influence of wind and terrain [1,2]. Fire growth typically follows an exponential pattern, with a critical intervention window of approximately 3–5 min after ignition [3]. Beyond this window, conventional suppression methods become less effective, underscoring the necessity of early detection systems [4].

Existing fire detection systems fall into two broad categories, each with distinct limitations. Sensor-based systems exhibit (i) detection delays because smoke or heat must first reach ceiling-mounted sensors [5], (ii) a lack of visual confirmation of the fire’s location and extent [6], and (iii) high false-alarm rates in dusty or steam-filled environments [7]. Traditional pixel-based algorithms are (i) highly susceptible to false alarms caused by lighting changes, sunlight reflections, steam or water vapor [8], and (ii) limited in spatial-context understanding, often failing to distinguish early-stage fire cues from visually similar yet harmless patterns [9,10]. These limitations have motivated the development of vision-based fire detection systems that can identify fires at their earliest stages through direct visual observation.

Recent advances in deep learning, particularly within the YOLO (You Only Look Once) family [11], have produced high-performance detectors from YOLOv3 [12] to the latest YOLOv12 [13]. Successive generations introduced key architectural innovations that improved both accuracy and efficiency: CSPDarknet in YOLOv4 [14], E-ELAN and RepConv in YOLOv7 [15], GELAN in YOLOv9 [16], a CNN-and-attention hybrid backbone in YOLOv11 [17], and enhanced multipath feature fusion in YOLOv12 [13]. Among lightweight variants, YOLOv5n [18] is one of the most compact models (approximately 1.9 M parameters) while maintaining competitive accuracy. It also supports ONNX and TensorRT export, facilitating deployment on resource-constrained edge platforms such as the NVIDIA Jetson Xavier NX. In this study, we adopt YOLOv5n as our baseline because it satisfies the requirements of efficiency, compatibility with edge devices, and strong small-object detection needed for early flame and smoke detection in constrained environments.

Applying generic object detectors to fire detection presents unique challenges. First, flames and smoke differ fundamentally in appearance: flames are bright, compact, and bounded by sharp high-frequency textures, whereas smoke is diffuse, semitransparent, and characterized by gradual intensity transitions [19,20]. Second, detecting both modalities within a single network creates a multimodal learning challenge, since the model must encode distinct spatial, textural, and opacity-related features at the same time, often leading to suboptimal representations and reduced accuracy [21]. Third, deployment on resource-limited edge devices requires architectures that maintain accuracy while meeting strict constraints on computation, memory, and power [22,23,24]. Local processing also provides low latency, robustness to unstable networks, and compliance with privacy regulations in sensitive locations such as homes and hospitals [25,26]. Edge computing avoids high-bandwidth streaming by processing video at the source, enabling scalable, location-aware fire surveillance even over low-speed networks [18,27]. However, platforms such as the Jetson Xavier NX, with less than 16 GB of unified memory and low-power CPUs [15], require careful balancing of model complexity and real-time performance. Prior work shows that aggressive simplification may increase throughput but often harms accuracy [28], whereas excessive pruning significantly degrades detection [29].

Previous studies have followed two main strategies. The first strategy enhances unified detectors through backbone replacement, attention integration, or decoupled prediction heads [19,21]. Examples include YOLOFM [30], YOLO-HF [31], and DCGC-YOLO [32]. Although these designs improve accuracy in some cases, a single network must still learn conflicting flame and smoke patterns, which can lead to unstable convergence and reduced generalization. The second strategy develops lightweight detectors, such as YOLOv5n [18], YOLOv7-tiny, and YOLOv8n, or enhanced variants like YOLOFM [30], EFA-YOLO [33], and Enhanced YOLOv7-Tiny [34], to achieve real-time performance on edge devices. However, these models often degrade noticeably when detecting small, low-contrast, or early-stage fire cues in cluttered environments. Segmentation-based approaches, including DeepSmoke [35] and Lightweight Smoke Segmentation [36], offer improved boundary localization but impose prohibitive computational costs for edge deployment.

These observations motivate a lightweight yet modular detection architecture that combines real-time efficiency, heterogeneous flame and smoke feature learning, and high sensitivity to small objects. To meet this need, we propose a dual-stream architecture that decouples flame and smoke detection into specialized branches, each tailored to its visual characteristics. We introduce two lightweight attention modules: Efficient Spatial Channel Fusion Module (ESCFM)++, optimized for small-scale flames with sharp boundaries and high-frequency textures; and Efficient Spatial Channel Fusion Module (ESCFM)-RS, designed to enhance sensitivity to diffuse, low-contrast smoke patterns. Integrated into a YOLOv5n backbone, these modules enable specialized feature learning without sacrificing computational efficiency. By separating feature extraction for flames and smoke, the approach reduces cross-modality interference while maintaining high inference speed. Extensive experiments show that the proposed method consistently outperforms state-of-the-art alternatives in both accuracy and efficiency, sustaining real-time performance on resource-constrained edge devices.

The main contributions of this work are

(i)

Dual-stream fire detector: a lightweight architecture that separates flame/smoke representation learning to mitigate feature interference versus unified models.

(ii)

Task-specific attention: ESCFM++ (flames) enhances spatial/channel selectivity for compact, high-frequency structures; ESCFM-RS (smoke) strengthens sensitivity to diffuse, low-contrast textures with depthwise convolutions and residual scaling.

(iii)

Edge-validated efficiency and robustness: ONNX/TensorRT deployment on Jetson Xavier NX with real-time throughput, validated through outdoor daytime/nighttime long-range live-stream tests that demonstrate reliable detection of small, early-stage flame cues under challenging illumination.

2. Related Work

Over the past decade, vision-based fire detection has advanced markedly. Early approaches in the mid-2000s relied on handcrafted image processing. Çelik et al. [37] introduced a Gaussian color model in RGB space, whereas Töreyin et al. [38] combined color thresholding with motion analysis to improve temporal coherence. Although promising for real-time processing, these rule-based methods often exhibited high false-positive rates under complex lighting and visually similar distractors, and they lacked standardized evaluation protocols, which limited their generalizability.

With the rise in deep learning, CNN-based methods significantly improved detection accuracy and practical deployability. Li and Zhao [39] compared VGG, ResNet, and Inception backbones within YOLO and Faster R-CNN frameworks, highlighting trade-offs between accuracy and computational cost. Jadon et al. [40] proposed FireNet, a MobileNetV2-based classifier with FireBlock and squeeze-and-excitation, achieving over 30 FPS on a Jetson Nano with only 1.26 M parameters. Nevertheless, handling low-contrast smoke and meeting strict edge constraints (latency, memory, and power) remain challenging, particularly when flame and smoke must be detected simultaneously under real-world nuisance factors.

2.1. Core Technical Challenges in Fire Detection (Feature/Gradient Interference)

A key challenge in integrated fire perception is that flames and smoke exhibit opposing visual statistics. Flames often appear as high-luminance regions with sharp boundaries and localized high-frequency textures, whereas smoke is low-contrast, diffuse, and gradually varying. This modality gap is reflected in the literature, where flame-centric detectors and smoke-centric detectors are often studied with different architectural emphases, including attention mechanisms such as CBAM [41], or modality-specific designs [10,33,34,35,36,42]. When both classes are learned jointly in a single backbone, unified detectors can suffer from representation interference and reduced sensitivity to weak early cues, motivating decoupled designs over purely unified learning in integrated settings [43,44,45,46,47,48,49]. This issue becomes more critical in early-warning scenarios, where cues are weak (tiny flames, thin smoke) and easily confused with distractors such as steam, fog, dust, or illumination changes.

2.2. Single-Stream Approaches (Flame-Centric and Smoke-Centric)

2.2.1. Single-Stream Approaches (Flame-Centric)

Flame-only models typically enhance sharp boundaries and high-frequency cues via attention or multi-scale refinements. Pan et al. [33] augmented YOLOv5s with an Efficient Feature Attention module, raising mAP@50 from 87.1% to 92.1% while sustaining >110 FPS. Lv et al. [10] combined CBAM [41] and Ghost modules, reducing parameters (7.2 M → 4.9 M) and boosting mAP@50 (86.7% → 92.3%) with speed gains (106 FPS → 118 FPS). Wu et al. [34] enhanced YOLOv7-Tiny with channel/spatial attention and dynamic upsampling, improving mAP@50 from 83.1% to 88.4% and precision/recall to 86.7%/84.6% at ≥150 FPS.

Strengths: strong flame accuracy and high throughput with modest architectural changes. Limitations: Despite their strong flame accuracy, many flame-centric single-stream variants remain deployment-unfriendly for edge devices because they often rely on heavier backbones (e.g., YOLOv5s) or additional attention and multi-scale components that increase memory traffic and latency. Moreover, these models ignore smoke, which is frequently the earliest warning cue, and are rarely benchmarked on tiny flames (<30 px) or evaluated with deployment-faithful end-to-end metrics (e.g., sustained FPS, memory footprint, and power) on embedded platforms.

2.2.2. Single-Stream Approaches (Smoke-Centric)

Smoke-only approaches often rely on segmentation-based localization or YOLO variants tuned for smoke/fog robustness. DeepSmoke [35] couples a ResNet-50 encoder with a multi-scale fusion decoder, achieving ≈80% mIoU, 85% precision, and 80% recall on 7 k outdoor images, outperforming U-Net and SegNet by 10–15 percentage points in mIoU. MobileNetV2-Seg [36] delivers 76.2% mIoU at 41.5 FPS with only 1.13 M parameters. For detection-based pipelines, Wang et al. [29] modified YOLOv5 with a multi-objective loss for fog robustness, raising mAP@50 from 63% to 72% and recall from 67% to 75%. He et al. [42] tailored YOLOv11x for forest-fire smoke, achieving 94.9% precision, 85.0% recall, and 90.1% mAP@50.

Strengths: improved sensitivity to diffuse smoke patterns and effective smoke localization. Limitations: These smoke-centric single-stream methods typically focus only on smoke and thus provide limited support for integrated early warning that also requires flame confirmation. In addition, segmentation-based pipelines are often computationally heavy (e.g., encoder–decoder with multi-scale decoders), making them less suitable for resource-constrained edge deployment. Even detection-based variants that report strong accuracy frequently rely on larger backbones (e.g., YOLOv11x) and do not explicitly incorporate smoke-specific architectural modules tailored to diffuse, low-contrast smoke statistics; consequently, robustness to confounders such as steam or mist and deployment-faithful end-to-end feasibility (sustained FPS, memory, and power under streaming) are still underexplored.

2.3. Joint Learning vs. Dual-Stream: Integrated Approaches

Integrated flame–smoke models can be grouped into three categories.

(i)

Single-stream YOLOv5 baseline (shared backbone): Ahn et al. [43] adopted an off-the-shelf YOLOv5 detector trained as a two-class model (flame and smoke). Their main contribution lies in constructing the dataset and deploying the unmodified YOLOv5 via ONNX/TensorRT for real-time inference, rather than designing separate flame/smoke streams or modifying the network architecture. Pros: simple integration and single-engine deployment. Cons: the shared backbone does not explicitly mitigate interference between flame and smoke representations, which can degrade early-stage sensitivity.

(ii)

Detection and classification cascades: Pincott et al. [44] combined YOLOv7/YOLOv8 with EfficientNet-B0 to classify flame, smoke, or background (97% accuracy), while Kim and Ruy [8] used an RGB + IR CNN for shipboard monitoring (94.1% accuracy). Pros: improves reliability via secondary verification or additional modalities. Cons: introduces latency and heavier computation, which can be unfavorable for real-time edge constraints.

(iii)

Unified YOLO detectors with generic enhancements: Examples include YOLOv5s with CBAM + GhostConv+BiFPN [45], YOLOv5n with FocalNext+QAHARep-FPN [30], DCGC-YOLO [32] and YOLOGX on YOLOv8 [46], as well as attention/fusion modules such as MLCA [47], AFPN [48], and YOLO-SAD [49]. Pros: strong benchmark gains within a single model. Cons: unified networks may still suffer from feature interference; robustness to dust, steam, and tiny early cues (<30 px) remains limited.

Overall, unified networks often suffer from feature interference, whereas parallel or cascaded systems introduce latency and heavy computation. This trade-off motivates an integrated yet lightweight solution that explicitly decouples flame and smoke learning.

2.4. Attention and Efficiency Mechanisms for Edge Deployment

For edge deployment, detectors must balance speed and accuracy. Prior work improves efficiency through: (i) lightweight backbones and attention, (ii) custom neck/head designs, (iii) temporal aggregation or segmentation-lite approaches, and (iv) quantization or distillation. Lv et al. [10] and Pan et al. [33] improved mAP@50 to >92% while sustaining > 110 FPS with Ghost + CBAM or EFA. Geng et al. [30] used FocalNext+QAHARep-FPN to raise mAP@50 from 95.3% to 97.5%, and He et al. [32] achieved similar gains with DCGCBlock and IoU anchors. Zhao [22] applied time-slicing aggregation (91.8% precision, 90.7% mAP@50) at 14.7 MB; MobileNetV2-Seg [36] achieved 76.2% mIoU at 41.5 FPS. EdgeFireSmoke++ [24] reached 91.2% mAP@50 with 2.9 M parameters at 42.7 FPS on a Jetson Nano.

Despite these optimizations, accuracy–size trade-offs persist, comprehensive end-to-end latency and power evaluations are rare, and many methods remain coupled to specific hardware stacks (e.g., TensorRT). Moreover, improving efficiency alone does not resolve the interference problem when flame and smoke are jointly learned in a shared backbone.

2.5. Research Gap and Positioning of This Work

Synthesizing prior work reveals three persistent gaps: (i) feature interference in unified models degrades accuracy when flames and smoke are learned jointly; (ii) low sensitivity to small cues (e.g., <30 px flames or thin smoke) hampers early detection; and (iii) incomplete edge validation, since most studies report only peak FPS/GPU behavior without end-to-end evaluation.

To address these issues, we propose a dual-stream YOLOv5n architecture that (a) employs dedicated flame and smoke streams to mitigate feature interference, (b) uses small-fire data mining (<15% flame area) to emphasize early-stage cues, (c) integrates specialized lightweight attention using ESCFM++ (flame) and ESCFM-RS (smoke) modules to improve detection of small cues, and (d) provides an edge-ready FP32 TensorRT implementation on the NVIDIA Jetson Xavier NX that sustains real-time throughput with negligible accuracy loss.

3. Proposed Method

This section presents a dual-stream detection framework for accurate and real-time perception of small-scale flames and smoke on edge devices. Unlike unified two-class detectors that learn both modalities within a shared representation, our framework explicitly decouples flame and smoke learning, deployment, and inference. This design choice is motivated by (i) modality-specific visual statistics that can cause representation interference in unified models and (ii) the need for deployment-faithful real-time evaluation on resource-constrained edge hardware.

3.1. Design Rationale and Contributions

Design Objective 1: Mitigate interference via dual-stream learning. Flame and smoke cues differ significantly: flames exhibit sharp edges and localized high-frequency textures, while smoke is diffuse and low-contrast. In a shared backbone, optimizing for one modality can weaken the other, especially under early-stage conditions (tiny flames and thin smoke). We therefore train and deploy two modality-specialized detectors to reduce negative coupling and preserve weak cues.

Design Objective 2: Use task-specific attention tailored to each modality. Rather than attaching a single generic attention module to a unified model, we design two lightweight attention variants: ESCFM++ for flames and ESCFM-RS for smoke. The two modules share a common placement strategy (before multi-scale heads P3–P5) but differ in fusion style to better match each modality’s signal structure (localized strong activations for flames vs. distributed weak patterns for smoke).

Design Objective 3: Ensure edge-ready, deployment-faithful real-time inference. Since the main claim is real-time edge applicability, we include the full conversion and runtime pipeline (ONNX → TensorRT FP32 → DeepStream) in the method description. This avoids reporting accuracy in isolation and aligns evaluation with the actual deployment setting.

The main contributions are summarized as follows:

(N1) A dual-stream YOLOv5n framework that explicitly decouples flame and smoke learning to reduce interference while remaining lightweight.

(N2) Two task-specific lightweight attention modules (ESCFM++ for flames, ESCFM-RS for smoke) are inserted at P3–P5 to enhance early-stage cues.

(N3) An edge-ready deployment pipeline with TensorRT/DeepStream enabling real-time dual-stream inference on Jetson Xavier NX.

3.2. Overall Pipeline and System Overview

Figure 1 illustrates the overall edge-oriented workflow comprising five stages: preprocessing, dual-stream training, model conversion, edge deployment, and real-time inference.

(i)

Preprocessing (early-stage emphasis): We load the D-Fire dataset and retain frames where flame or smoke occupies ≤ 15% of the image area to emphasize early-stage cues. The data are then separated into flame and smoke subsets for modality-specific training.

(ii)

Dual-stream training (decoupled optimization): Two YOLOv5n detectors are trained independently: the flame stream integrates three ESCFM++ blocks, and the smoke stream integrates three ESCFM-RS blocks. In both cases, blocks are inserted before the P3–P5 detection heads while keeping the backbone and neck unchanged (see Figure 2).

(iii)

Model conversion (deployment alignment): Trained models are exported to ONNX in FP32 precision and converted to TensorRT FP32 engines with layer fusion and kernel auto-tuning to preserve accuracy.

(iv)

Edge deployment (runtime integration): The TensorRT engines are deployed on NVIDIA Jetson Xavier NX using DeepStream for low-latency streaming inference.

(v)

Real-time inference (parallel dual-stream execution): A single camera stream is preprocessed once (resize/normalize) and fed into two parallel engines. Outputs are fused at the system level to support early warning alerts for small flames and thin smoke.

Figure 2. Architecture of the proposed ESCFM enhanced YOLOv5n. ESCFM++ (flame) and ESCFM-RS (smoke) are inserted at multiple scales (P3–P5) immediately before the heads to specialize each modality.

Figure 2. Architecture of the proposed ESCFM enhanced YOLOv5n. ESCFM++ (flame) and ESCFM-RS (smoke) are inserted at multiple scales (P3–P5) immediately before the heads to specialize each modality.

3.3. Dual YOLOv5n Architecture with Specialized Attention Modules

Figure 2 shows the overall architecture. The backbone follows the standard YOLOv5n design with CBS, C3, and SPPF blocks. The neck uses a PANet/FPN structure to fuse multi-scale features at P3 (small), P4 (medium), and P5 (large). To enhance early-stage cues without increasing backbone complexity, we insert ESCFM blocks immediately before each detection head at P3–P5. The placement is identical in both streams; only the module type differs by modality (ESCFM++ for flame, ESCFM-RS for smoke).

3.4. ESCFM++ Module for Flame Detection

ESCFM++ is a lightweight multi-branch attention mechanism designed for flame cues that are sparse and localized. As shown in Figure 3, it consists of parallel average-pooling and max-pooling branches followed by lightweight transformations. The refined features are fused through additive residual aggregation, which preserves weak but meaningful signals while emphasizing sharp flame edges and ignition points.

Mathematical formulation of ESCFM++. Let the input feature map be $X\in R^{C\times H\times W}.$ The ESCFM++ module computes the output $Y$ through three stages:

Average pooling attention

$${\mathrm{F}}_{\mathrm{avg}}=\mathsf{\sigma }\left({\mathrm{W}}_3\cdot \mathrm{R}\mathrm{e}\mathrm{L}\mathrm{U}\left({\mathrm{W}}_2\cdot \left({\mathrm{W}}_1\cdot \mathrm{A}\mathrm{v}\mathrm{g}\mathrm{P}\mathrm{o}\mathrm{o}\mathrm{l}\left(\mathrm{X}\right)\right)\right)\right),$$

(1)

Max pooling attention

$${\mathrm{F}}_{\max }=\mathsf{\sigma }\left({\mathrm{W}}_3\cdot \mathrm{R}\mathrm{e}\mathrm{L}\mathrm{U}\left({\mathrm{W}}_2\cdot \mathrm{R}\mathrm{e}\mathrm{L}\mathrm{U}\left({\mathrm{W}}_1\cdot \mathrm{M}\mathrm{a}\mathrm{x}\mathrm{P}\mathrm{o}\mathrm{o}\mathrm{l}\left(\mathrm{X}\right)\right)\right)\right),$$

(2)

Additive residual fusion

$$\mathrm{Y}=\mathrm{X}+{\mathrm{F}}_{\mathrm{avg}}+{\mathrm{F}}_{\max }.$$

(3)

Equation (1) captures global semantic context by applying average pooling across spatial dimensions. The pooled vector is transformed through a stack of convolutional layers with ReLU activations, and the final output is passed through the sigmoid function $\mathsf{\sigma }$, producing a smooth attention map that emphasizes semantically meaningful regions, particularly useful for blurry or weakly textured flames.

In contrast, Equation (2) highlights sparse but highly activated flame features by replacing average pooling with max pooling. This path captures sharp edges and ignition points, reinforcing strong local variations in the flame region, while applying the same transformation pipeline to maintain parameter sharing and consistency across branches.

Finally, Equation (3) adds both refined attention maps to the original input X via a residual connection. This fusion preserves the original spatial and contextual information while amplifying attention-enhanced cues. Unlike multiplicative attention (e.g., SE or CBAM), the additive design ensures that weak but meaningful features are not suppressed.

3.5. ESCFM-RS Module for Smoke Detection

ESCFM-RS targets diffuse and low-contrast smoke patterns. As shown in Figure 4, it adopts residual spatial attention with lightweight convolutions to maintain spatial sensitivity. Unlike ESCFM++, ESCFM-RS applies the fused attention map multiplicatively and adds a residual path, which is effective for enhancing distributed weak smoke signals while keeping computation minimal.

Mathematical formulation of ESCFM-RS. Let the input feature map be $X\in R^{C\times H\times W}$. The ESCFM-RS module produces output Y in three steps:

Average pooling attention

$$F_{\mathrm{avg}}=\mathsf{\sigma }\left(W_2\cdot \mathrm{ReLU}\left(\mathrm{DW}\left(W_1\cdot \mathrm{AvgPool}\left(X\right)\right)\right)\right)$$

(4)

Max pooling attention

$$F_{\max }=\mathsf{\sigma }\left(W_2\cdot \mathrm{ReLU}\left(\mathrm{DW}\left(W_1\cdot \mathrm{MaxPool}\left(X\right)\right)\right)\right)$$

(5)

Residual emphasis with multiplicative attention

$$Y=X+X\cdot \mathsf{\sigma }\left(F_{\mathrm{avg}}+F_{\max }\right)$$

(6)

Equation (4) extracts smooth, diffuse smoke textures via average pooling, whereas Equation (5) captures sharply activated smoke cues through max pooling. Finally, Equation (6) fuses the two attention maps, multiplies them with the input features, and adds a residual connection. This combination reinforces both strong and weak smoke signals while maintaining computational efficiency.

3.6. Dual Inference Strategy for Edge Deployment

Figure 5 illustrates the deployment-faithful dual-stream inference pipeline. A single camera stream is preprocessed once (resize to 416 × 416 and normalization) and then routed to two parallel engines: YOLOv5n+ESCFM++ for flames and YOLOv5n+ESCFM-RS for smoke. For real-scenario evaluation, we capture outdoor video streams using a consumer-grade camera (webcam) under daytime and nighttime conditions, including long-range views where flames appear as tiny cues on the screen. Both detectors are exported to ONNX (FP32) and compiled into TensorRT FP32 engines (with layer fusion and kernel auto-tuning), and are executed within a DeepStream pipeline on Jetson Xavier NX. The two outputs are synchronized and can be optionally fused to trigger early-warning alerts. End-to-end throughput/latency and detection performance under this outdoor real-scenario setup are reported in Section 4.7 to validate real-time applicability.

4. Experimental Results

This section presents a comprehensive evaluation of the proposed models and modules, including deployment on an edge device. The experimental results are organized into seven parts: (1) Experimental Environment and Dataset Preparation (Section 4.1), (2) Performance Evaluation Metrics (Section 4.2), (3) Comparison with Existing YOLO Models (Section 4.3), (4) Comparison with Related Models (Section 4.4), (5) Ablation Study for Model Optimization (Section 4.5), (6) Edge Computing Performance on Jetson Xavier NX (Section 4.6), and (7) Real-World Outdoor Live-Stream Case Study (Section 4.7).

4.1. Experimental Environment and Dataset Preparation

Experiments were conducted on a high-performance workstation, and the D-Fire dataset was preprocessed to emphasize early-stage fire cues.

Table 1. Training environment and hyperparameters.

Item	Details
Hardware	GPU: NVIDIA GeForce RTX 4080 (16 GB VRAM), CPU: Intel 9-13900 K, Memory: 64 GB
Operating system	Windows 11
Software framework	PyTorch 2.1.0, CUDA 12.1, cuDNN 8.9
YOLOv5 model	YOLOv5n (Nano)
Learning hyperparameters	Learning rate: 0.01; weight decay: 0.0005; momentum: 0.937
Max epochs	3000
Batch size	8
Warm-up phase	Epochs: 3; warm up momentum: 0.8; warm up bias LR: 0.1

,

Table 2. Applied data augmentation techniques and settings.

Technique	Description	Probability/Range
HSV transform	Adjusts hue, saturation, and value (brightness)	Hue: ±1.5%, Saturation.: ±70%, Value.: ±40%
Mosaic	Combines four images to generate a new training sample	Probability: 100%
Flip	Horizontal flip	Probability: 50%
Translation	Random translation	±10%
Rotation	Random rotation	±10°
Scale	Random scaling	±50%

,

Table 3. Dataset composition before preprocessing (original D-Fire).

Class	Images	Bounding Boxes
Only fire	1164	14,692
Only smoke	5867	11,865
Fire and smoke	4658	-
None	9838	-

and

Table 4. Dataset composition after preprocessing (used in experiments).

Class (Processed)	Train	Val	Total
Flame only	4161	975	5136
Smoke only	3385	798	4183
Flame and smoke	4161	975	5136

summarize the training environment, augmentation settings, and final dataset composition.

Hardware and software. Table 1 summarizes the training environment and hyperparameters used in this study. Training was performed on an NVIDIA GeForce RTX 4080 GPU (16 GB VRAM; NVIDIA Corporation, Santa Clara, CA, USA) with an Intel Core i9 13900 K CPU and 64 GB RAM. The software stack comprised Windows 11, PyTorch 2.1.0, CUDA 12.1, and cuDNN 8.9. YOLOv5n (Nano) was trained with an initial learning rate of 0.01, weight decay of 0.0005, and momentum of 0.937. A three-epoch warm-up is used, with momentum set to 0.8 and the bias learning rate to 0.1, to stabilize convergence.

Data augmentation. Standard YOLO augmentations (Table 2) were applied: HSV hue/saturation/value shifts of ±1.5%/±70%/±40%; Mosaic to combine four images; horizontal flip (50%); translation (±10%); rotation (±10°); and scaling (up to ±50%). MixUp and CutMix were disabled to keep experiments consistent.

Dataset preparation. Table 3 summarizes the original D-Fire dataset, which contains four categories: fire only (1164 images), smoke only (5867), fire + smoke (4658), and none. For the flame-related data, we first merged the “fire only” and “fire+smoke” categories into a single pool of 5822 flame-containing frames. We then applied a filtering step that removes frames in which the flame bounding-box area exceeds 15% of the image, so that the remaining samples emphasize smaller or earlier-stage flames. After this filtering, 5136 images are retained.

We next reorganized and resplit the data for training and evaluation; the final splits are summarized in Table 4. Dataset composition after preprocessing (used in experiments) is as follows: the flame-containing set comprises 5136 images (4161 training (train), 975 validation (val)), the smoke-only set comprises 4183 images (3385 train, 798 val), and the unified fire+smoke set also comprises 5136 images (4161 train, 975 val). Note that the “flame only” and “fire+smoke” columns in Table 4 correspond to two different annotation configurations applied to the same 5136 flame-containing frames: in the former, only flame bounding boxes are used, whereas in the latter both flame and smoke labels are retained. This filtering and reorganization consolidate all flame-containing frames and remove large (>15%) flame regions, thereby increasing the diversity and representativeness of smaller flame patterns used for training, which is beneficial for early-fire detection.

As visualized in Figure 6, the fire-only category increased from 1164 to 5136 images, whereas the smoke-only only decreased from 5867 to 4183. This filtering step substantially increased the proportion of small flame samples, improving suitability for early-stage fire detection.

4.2. Performance Evaluation Metrics

This study evaluates the proposed detection models using three primary metrics: precision, recall, and mean average precision at an IoU threshold of 0.5 (mAP@50). These metrics quantify the relationship between detected objects and ground truth annotations, providing a comprehensive measure of detection accuracy, coverage, and overall effectiveness.

Let TP denote true positives (correct detections), FP false positives (incorrect detections), and FN false negatives (missed objects). Let N be the number of classes and ${AP}_i$ the average precision for the i-th class. The metrics are defined as follows.

Precision measures the proportion of correct detections among all predictions Equation (7); a higher value indicates fewer false positives and thus greater reliability:

$$\mathrm{Precision}={\displaystyle \frac{\mathrm{TP}}{\mathrm{TP}+\mathrm{FP}}}.$$

(7)

Recall measures the proportion of ground truth objects that are correctly detected Equation (8); a higher value implies fewer false negatives and better coverage:

$$\mathrm{Recall}={\displaystyle \frac{\mathrm{TP}}{\mathrm{TP}+\mathrm{FN}}}.$$

(8)

mAP@50 is the mean average precision computed at an intersection over union (IoU) threshold of 0.5 Equation (9); it aggregates per class AP over all classes:

$$\mathrm{mAP}@50={\displaystyle \frac{1}{N}}\sum _{i=1}^{N}A{P}_i, \mathrm{at} \mathrm{IoU}=0.5.$$

(9)

4.3. Comparison with Existing YOLO Models

This section compares the proposed YOLOv5n-based detectors, enhanced with ESCFM++ and ESCFM-RS for flame only and smoke only detection, respectively, against standard YOLO architectures from YOLOv3 tiny to YOLOv12nv. Performance is evaluated using precision, recall, mAP@50, and model size (parameters, M).

To ensure a fair comparison, all models were trained under identical experimental settings: the same data augmentation pipeline, CIoU loss, SiLU activation, non-maximum suppression configuration, and training hyperparameters. Each YOLO variant was trained separately on flame-only and smoke-only datasets to assess class-specific detection capability. This isolated training strategy avoids cross-class feature interference and highlights each model’s inherent ability to capture class-specific visual cues.

The results (

Table 5. Training results of YOLO models for flame-only and smoke-only detection.

Model	Flame			Smoke
	Precision (%)	Recall (%)	mAP@50 (%)	Precision (%)	Recall (%)	mAP@50 (%)	Params (M)
YOLOv3 tiny	57.0	52.0	49.68	83.0	46.0	72.42	8.7
YOLOv4 tiny	72.0	54.0	57.54	77.0	77.0	81.39	6.1
YOLOv5n	73.0	70.2	73.80	85.7	82.8	88.00	1.8
MSA YOLOv5n [50]	73.9	68.7	73.40	85.7	83.1	88.10	1.82
YOLOv6n	72.3	67.0	72.30	86.4	66.5	86.50	4.7
YOLOv7 tiny	71.19	71.88	74.24	89.04	81.86	87.84	7.0
YOLOv8n	73.2	66.7	73.40	86.2	83.5	88.50	3.2
YOLOv9t	73.0	67.8	73.10	88.8	84.6	89.00	2.0
YOLOv10n	71.1	68.1	71.80	86.2	81.9	86.80	2.3
YOLOv11n	74.9	64.7	72.70	85.2	80.0	86.70	2.6
YOLOv12n	72.1	67.2	72.80	88.9	83.2	87.70	2.6
YOLOv5n ESCFM++ (ours)	74.1	70.4	74.50	-	-	-	1.89
YOLOv5n ESCFM-RS (ours)	-	-	-	89.4	81.9	89.20	1.89

) show that the YOLOv5n-based models consistently achieve an excellent tradeoff between accuracy and efficiency. Despite its compact size of only 1.8 M parameters, the baseline YOLOv5n attains 73.8% mAP@50 for flame detection and 88.0% mAP@50 for smoke detection, outperforming larger models such as YOLOv6n (86.5% mAP@50, 4.7 M) and YOLOv7 tiny (87.8% mAP@50, 7.0 M) in terms of parameter efficiency.

For flame detection, integrating the ESCFM++ module raises mAP@50 from 73.8% to 74.5%, with slight gains in both precision (73.0% → 74.1%) and recall (70.2% → 70.4%), while maintaining the smallest model size (1.89 M parameters). This demonstrates the module’s effectiveness in enhancing small-scale flame cues without sacrificing compactness.

For smoke detection, the proposed ESCFM-RS module achieves the highest mAP@50 (89.2%) among all models, surpassing strong baselines such as YOLOv9t (89.0%) and YOLOv12n (87.7%), while retaining an equally lightweight footprint (1.89 M parameters). This confirms that the residual spatial attention design effectively captures thin and dispersed smoke patterns.

Overall, the dual ESCFM design provides task-specific optimization: ESCFM++ is best suited for flame detection, and ESCFM-RS for smoke detection. Both variants preserve real-time deployability thanks to their minimal model size.

Table 6. Joint flame and smoke detection results (unified two-class training).

Model	Precision (%)	Recall (%)	mAP@50 (%)	Params (M)
YOLOv3 tiny	60.00	47.00	56.68	8.70
YOLOv4 tiny	72.00	57.00	66.42	6.10
YOLOv5n	79.60	74.50	78.80	1.80
MSA YOLOv5n [50]	80.30	74.70	78.80	1.82
YOLOv6n	78.40	61.40	78.40	4.70
YOLOv7 tiny	81.08	76.44	80.16	7.00
YOLOv8n	79.40	73.10	79.00	3.20
YOLOv9t	81.20	73.90	79.50	2.00
YOLOv10n	81.10	70.90	78.70	2.30
YOLOv11n	79.20	72.80	78.50	2.60
YOLOv12n	80.40	73.20	79.70	2.60
YOLOv5n ESCFM++ (ours)	80.00	72.20	78.70	1.89
YOLOv5n ESCFM-RS (ours)	81.36	74.62	80.20	1.89

shows the results of joint flame and smoke detection experiments. YOLOv5n achieved 79.6% precision, 74.5% recall, and 78.8% mAP@50 with only 1.8 M parameters, providing a strong lightweight baseline. The proposed YOLOv5n + ESCFM++ recorded 80.0% precision, 72.2% recall, and 78.7% mAP@50 with 1.89 M parameters, maintaining baseline level accuracy while preserving compactness. The proposed YOLOv5n + ESCFM-RS achieved the best overall performance with 81.4% precision, 74.6% recall, and 80.2% mAP@50, outperforming larger models such as YOLOv7 tiny (80.2%, 7.0 M) and YOLOv9t (79.5%, 2.0 M).

Compared to the single class training results (Table 5), both ESCFM variants showed a marginal reduction in flame detection (≈0.3%) and a more pronounced drop in smoke detection (up to 9.0%), indicating that smoke detection is more sensitive to feature interference under joint training.

Table 7. Class-wise results of the unified two-class (flame and smoke) detector.

Model	Class	Precision (%)	Recall (%)	mAP@50 (%)
YOLOv5n ESCFM++ (ours)	Flame	72.30	67.00	73.10
	Smoke	86.40	66.50	84.30
YOLOv5n ESCFM-RS (ours)	Flame	73.60	68.00	74.40
	Smoke	87.20	67.90	85.60

presents the class-wise performance of the proposed flame and smoke models. For flame detection, ESCFM++ and ESCFM-RS achieved 73.1% and 74.4% mAP@50, respectively, with precision values of 72.3% and 73.6% and recall values of 67.0% and 68.0%. For smoke detection, ESCFM++ reached 84.3% mAP@50 (precision 86.4%, recall 66.5%), while ESCFM-RS achieved the best performance with 85.6% mAP@50 (precision 87.2%, recall 67.9%).

Compared to the single class baselines, flame detection decreased only marginally (~0.3%), whereas smoke detection dropped significantly (~9.0%). These results confirm that flame detection is relatively resilient to inter-class interference, whereas smoke detection is more vulnerable due to its diffuse, low-contrast visual patterns. The spatial refinement in ESCFM-RS alleviates part of this degradation but does not fully close the gap with specialized smoke-only models. To further illustrate the performance differences, Figure 7 shows sample detection results for the proposed models trained on (a) flame-only and (b) smoke-only datasets.

4.4. Comparison with Related Models

We compare the proposed ESCFM++ and ESCFM-RS against a broad set of state-of-the-art detectors spanning classical two-stage frameworks and modern lightweight one-stage designs. The baselines include: (i) two-stage detectors (Faster R-CNN [51], EfficientDet [52]); (ii) transformer-based RT-DETRv2 [53]; (iii) YOLO-based flame/smoke detectors (YOLOFM [30], YOLO-SAD [49]); and (iv) YOLOv5n variants augmented with attention modules (SKNet [54], CBAM [41], Self Attention [55]). All models are evaluated on flame-only and smoke-only datasets using precision, recall, mAP@50, and model size (M).

Table 8. Training results of comparative models for flame-only and smoke-only detection.

Dataset	Model	Reduction	Precision (%)	Recall (%)	mAP@50 (%)	Params (M)
Flame	Faster R-CNN [51]	-	71.70	49.70	71.70	41.00
	EfficientDet-D0 [52]	-	30.60	49.13	64.40	3.90
	RT-DETRv2 [53]	-	40.20	58.80	74.20	20.00
	YOLOFM [30]	-	71.90	69.10	72.00	3.60
	YOLO-SAD [49]	-	74.20	70.60	74.50	16.20
	YOLOv5n + SKNet [54]	24	73.80	67.90	72.40	1.98
	YOLOv5n + Self Attention [55]	24	74.60	68.50	73.40	2.05
	YOLOv5n + CBAM [41]	16	72.60	70.00	74.20	1.90
	YOLOv5n + ESCFM++ (ours)	24	74.10	70.40	74.50	1.89
Smoke	Faster R-CNN	-	60.70	46.80	60.70	41.00
	EfficientDet-D0	-	53.50	66.70	87.70	3.90
	RT-DETRv2	-	58.90	73.20	88.70	20.00
	YOLOFM	-	88.20	82.10	87.30	3.60
	YOLO-SAD	-	87.30	84.30	88.40	16.20
	YOLOv5n + SKNet	24	86.20	82.30	88.40	1.98
	YOLOv5n + Self Attention	8	87.90	81.20	88.10	2.05
	YOLOv5n + CBAM	24	88.00	81.90	88.60	1.90
	YOLOv5n + ESCFM-RS (ours)	14	89.40	81.90	89.20	1.89

highlights consistent family-level trends. For flame-only detection, YOLO- based variants yield strong results, with precision 72–75% and recall 68–71%. Among them, YOLO-SAD and the proposed YOLOv5n + ESCFM++ attain the highest mAP@50 (74.5%). By comparison, RT-DETRv2 reaches a comparable mAP@50 (74.2%) but suffers from lower precision (40.2%) and recall (58.8%), indicating difficulty modeling small, irregular flame structures. Conventional detectors such as Faster R-CNN and EfficientDet D0 lag behind at 71.7% and 64.4% mAP@50, respectively.

For smoke-only detection, YOLO-based models again dominate, typically exceeding 86% precision and 81% recall. The proposed YOLOv5n + ESCFM-RS achieves the best precision (89.4%) and mAP@50 (89.2%), demonstrating robustness to thin and dispersed smoke. RT-DETRv2 attains a competitive mAP@50 (88.7%) but exhibits poor precision (58.9%), suggesting unstable confidence calibration; EfficientDet D0 similarly shows relatively low precision (53.5%) despite moderate recall (66.7%).

Overall, lightweight YOLO-based detectors with attention mechanisms, particularly ESCFM++ and ESCFM-RS, offer the most favorable accuracy-efficiency trade-off, outperforming transformer-based and two-stage alternatives on both flame and smoke detection tasks.

4.5. Ablation Study for Model Optimization

This study quantifies how post-processing strategies, IoU-based loss functions, and activation functions influence the performance of the proposed framework. The baseline ESCFM adopts a dual-branch design with adaptive max/average pooling, 1 × 1 convolutions, ReLU, and element-wise fusion with a residual path. It is inserted immediately before the three detection heads (P3–P5) of YOLOv5n without modifying the backbone.

We evaluate two groups of ablations under identical dataset splits and training/inference settings: (i) post-processing methods (NMS vs. Soft NMS) combined with IoU losses (GIoU, DIoU, CIoU), summarized in

Table 9. Post-processing and IoU loss comparison.

Dataset	Model	Post- Processing	IoU	Activation	Precision (%)	Recall (%)	mAP@50 (%)
Flame	YOLOv5n	NMS [56]	GloU [50]	SiLU [54]	72.80	69.50	73.10
			GloU		73.90	68.70	73.40
		NMS	DluU [55]	SiLU	74.20	67.10	72.30
	MSA-YOLOv5n [57]		CloU [55]		73.90	68.70	73.40
			GloU		72.40	69.60	73.50
		Soft-NMS [53]	DloU	SiLU	73.40	67.90	73.30
			CloU		72.40	69.60	73.50
			GloU		74.20	69.10	73.80
		NMS	DloU	SiLU	73.00	69.00	73.40
	YOLOv5n + ESCFM		CloU		75.40	68.20	73.50
			GloU		74.70	69.00	73.20
		Soft-NMS	DloU	SiLU	74.80	68.40	73.10
			CloU		74.70	69.00	73.20
Smoke	YOLOv5n	NMS	GloU	SiLU	85.70	82.80	88.00
			GloU		85.70	83.10	88.10
		NMS	DloU	SiLU	86.80	82.70	88.00
	MSA-YOLOv5n		CloU		85.70	83.10	88.10
			GloU		86.50	82.70	87.60
		Soft-NMS	Dlou	SiLU	87.30	80.50	87.60
			CloU		86.50	82.70	87.60
			GloU		86.80	83.00	88.60
		NMS	DloU	SiLU	85.80	83.40	87.00
	YOLOv5n + ESCFM		CloU		85.80	83.40	87.00
			GloU		86.20	84.30	87.80
		Soft-NMS	DloU	SiLU	85.70	82.30	87.80
			CloU		86.20	84.30	87.70

and (ii) activation functions (SiLU/Swish, Mish, Hard Swish, GELU, Leaky ReLU, ReLU), reported in

Table 10. Activation function comparison.

Dataset	Model	Post-Processing	IoU	Activation	Precision (%)	Recall (%)	mAP@50 (%)
	YOLOv5n	NMS	GloU	SiLU	72.8	69.5	73.1
				SiLU	74.2	69.1	73.8
				Hardswish [58]	74.3	68.1	72.7
				Mish [59]	75.1	68.0	73.2
				EfficientMish [60]	73.6	69.1	72.9
				FreLU [61]	70.8	69.1	71.7
Flame	YOLOv5n + ESCFM	NMS	GloU	AconC [62]	72.9	67.2	72.3
				MetaAconC [62]	73.6	67.0	73.0
				GELU [63]	73.9	67.6	72.9
				Leaky ReLU [64]	73.0	68.6	72.3
				ReLU [65]	71.9	67.5	72.7
				ReLUN [66]	71.0	67.9	72.1
				Soft Exponential [67]	37.9	30.1	25.0
	YOLOv5n	NMS	GloU	SiLU	86.3	84.4	88.5
				SiLU	86.8	83.0	88.6
				Hardswish	85.0	83.2	87.0
				Mish	87.4	81.9	87.9
				EfficientMish	86.8	80.9	87.2
				FreLU	86.5	80.9	85.5
Smoke	YOLOv5n + ESCFM	NMS	GloU	AconC	86.4	80.5	86.3
				MetaAconC	84.7	79.9	86.1
				GELU	85.8	81.9	87.2
				Leaky ReLU	85.7	83.5	87.6
				ReLU	87.8	80.7	87.2
				ReLUN	85.8	82.6	86.9
				Soft Exponential	63.9	54.8	53.4

. All experiments were conducted separately on flame-only and smoke-only datasets.

For the flame dataset, pairing NMS with GIoU produced the highest mAP@50 under ESCFM (73.8%) and outperformed Soft NMS + GIoU (73.2%). With DIoU and CIoU losses, NMS also remained slightly higher (73.4% vs. 73.1%; 73.5% vs. 73.2%). On the baseline MSA YOLOv5n, however, Soft NMS achieved comparable or better results under certain losses (e.g., DIoU: 73.3% vs. 72.3%), indicating that the optimal post-processing choice depends on both the loss function and the underlying architecture.

For the smoke dataset, ESCFM combined with NMS + GIoU achieved the best mAP@50 (88.6%), compared to Soft NMS + GIoU (87.7%). For DIoU and CIoU, Soft NMS provided marginal improvements (87.8%/87.7% vs. 87.0%/87.0%). Conversely, on the MSA YOLOv5n baseline, NMS consistently outperformed Soft NMS across all IoU variants (88.1%/88.0%/88.1% vs. 87.6%/87.6%/87.6%).

Overall, the post-processing and loss result in Table 9 show that GIoU combined with NMS emerged as the most stable and reliable configuration across datasets and is therefore adopted as the default.

Regarding activation functions (Table 10), SiLU consistently yielded the strongest results with ESCFM (73.8% for flames; 88.6% for smoke). Mish improved precision on flames (75.1%) but typically reduced recall (68.0%), resulting in a lower overall mAP@50 than SiLU (73.2%). Hard Swish, Leaky ReLU, and GELU followed closely behind, generally trailing SiLU by about one point in mAP@50, while standard ReLU remained suboptimal under the same protocol. Unless otherwise specified, subsequent experiments and deployment analyses therefore use NMS + GIoU + SiLU as the default configuration, as this combination maximized mAP@50 on both flame and smoke datasets with ESCFM.

4.6. Edge Computing Performance

We evaluate the real-time deployability of the proposed dual-stream architecture on an embedded edge platform using the NVIDIA Jetson Xavier NX (20 W, six-core mode). All compared models, including YOLOv5n, YOLOv9t, YOLOv11, YOLOv12n, YOLOFM, YOLO-SAD, and the proposed flame and smoke specific detectors, were converted to TensorRT (FP32) to ensure identical inference settings.

The evaluation procedure was as follows:

(i)

Compare parameter sizes before and after TensorRT optimization.

(ii)

Benchmark dual stream inference throughput and latency.

(iii)

Analyze single-stream performance for flame-only and smoke-only models.

(iv)

Perform statistical significance testing to validate mAP@50 improvements.

(v)

Visualize qualitative detection results in real-world scenarios.

We report frames per second (FPS), GPU utilization, RAM usage, and power consumption across all configurations. Statistical analysis indicates that the proposed models consistently surpass the YOLOv5n baseline in mAP@50 while maintaining competitive throughput and resource efficiency. Qualitative results from real-world scenes further demonstrate robust performance for practical fire perception applications.

Table 11. Edge device setup.

Component	Specification
Device	NVIDIA Jetson Xavier NX
GPU	384 core NVIDIA Volta with 48 Tensor Cores
CPU	6 core NVIDIA Carmel ARMv8.2 64 bit @ 1.4 GHz
Memory	8 GB LPDDR4x (51.2 GB/s)
Storage	16 GB eMMC 5.1
Power mode	20 W (6 core mode)
Operating system	Ubuntu 20.04 LTS (JetPack 5.0.2, L4T 35.1.0)
Inference resolution	640 × 640 × 3
Deployment	TensorRT (FP32) with layer fusion and kernel-level optimizations
Metrics collected	FPS, GPU utilization, RAM usage, and power consumption (30 run average)

summarizes the edge device used for real-time deployment. The hardware platform is an NVIDIA Jetson Xavier NX (NVIDIA Corporation, Santa Clara, CA, USA), featuring a 384-core NVIDIA Volta GPU with 48 Tensor Cores and a six-core NVIDIA Carmel ARMv8.2 64-bit CPU at 1.4 GHz. The device provides 8 GB LPDDR4x memory (51.2 GB/s) and 16 GB eMMC 5.1 storage and operates in 20 W 6 core mode. The software stack was Ubuntu 20.04 LTS with JetPack 5.0.2 (L4T 35.1.0). For inference, the input resolution was set to 640 × 640 × 3, aligned with common YOLO-based detectors. Deployment used TensorRT (FP32) with layer fusion and kernel-level optimizations for efficient inference. We collected system-level metrics, including frames per second (FPS), GPU utilization, RAM usage, and average power consumption, over 30 inference runs, providing a comprehensive assessment of efficiency and feasibility for real-time edge AI under strict hardware and power budgets.

Table 12. Model Parameters Before and after TensorRT FP32 Conversion.

Model	Params (M) Before	Params (M) After FP32	TensorRT Engine Size (MB)
YOLOv5n	1.80	1.76	7.04
YOLOv9t	2.00	1.97	7.88
YOLOv11n	2.60	2.58	10.33
YOLOv12n	2.60	2.56	10.23
YOLOFM	3.63	3.63	14.52
YOLO-SAD	7.02	7.01	28.05
Proposed (Flame)	1.89	1.78	7.12
Proposed (Smoke)	1.89	1.79	7.15

reports parameter counts and TensorRT engine sizes before and after FP32 compilation. Only marginal reductions are observed after compilation, indicating that FP32 TensorRT provides negligible compression of parameter scale. Among the baselines, YOLOv5n is the lightest (1.8 M parameters, 7.04 MB engine), whereas YOLO-SAD is the heaviest (7.02 M parameters, 28.05 MB). Intermediate models such as YOLOv9t (2.00 M → 1.9 M; 7.88 MB) and YOLOv11n (2.60 M → 2.58 M; 10.33 MB) exhibit moderate complexity. For the proposed detectors, both flame and smoke specific variants remain lightweight (about 1.89 M before, 1.78–1.79 M after FP32), yielding compact engines (7.12 MB and 7.15 MB, respectively). These results confirm that the proposed models preserve nearly the same computational footprint as YOLOv5n while integrating specialized attention modules.

Table 13. Real-time inference performance on Xavier NX (single and dual stream).

Model	FPS		GPU Load (%)		RAM (MB)		Power (W)
	Single	Dual	Single	Dual	Single	Dual	Single	Dual
YOLOv5n	59.97	29.66	91	97	4012	5721	15.75	16.70
YOLOv9t	43.88	19.05	97	97	4075	5769	17.60	16.40
YOLOv11n	50.55	21.58	97	97	3846	5294	17.25	17.00
YOLOv12n	36.77	15.27	97	97	3921	6854	18.00	17.80
YOLOFM	28.31	11.66	98	98	4146	7195	18.10	18.30
YOLO-SAD	31.68	13.28	98	98	4049	6576	18.80	18.10
Proposed (Flame)	59.76	28.35	90	97	3952	5866	15.90	17.30
Proposed (Smoke)	59.96	28.34	90	97	3958	5866	15.70	17.00

summarizes real-time inference on the NVIDIA Jetson Xavier NX under single and dual stream configurations. YOLOv5n delivers the highest efficiency with 59.97 FPS (single) and 29.66 FPS (dual), serving as the lightweight reference. YOLOv9t (43.88/19.05 FPS) and YOLOv11n (50.55/21.58 FPS) offer moderate throughput but already show noticeable drops in dual stream mode. By contrast, YOLOv12n, YOLOFM, and YOLO-SAD suffer substantial slowdowns in dual stream settings (15.27, 11.66, and 13.28 FPS, respectively), suggesting that their additional architectural components, such as enhanced feature blocks and attention modules, introduce significant computational overhead, limiting real-time suitability at the edge.

The proposed flame-specific and smoke-specific detectors maintain throughput nearly identical to YOLOv5n, 59.7 FPS (single) and 28.3 FPS (dual), while also showing slightly lower GPU utilization (about 90% vs. 97–98% for other baselines), indicating improved resource efficiency. RAM usage (3950 MB single, 5860 MB dual) and power draw (15.7–15.9 W single, 17.0–17.3 W dual) remain stable and comparable to YOLOv5n, confirming that the proposed models preserve real-time capability on edge hardware while providing domain-specific accuracy gains.

To assess generalization, we additionally ran edge-deployed inference on four previously unseen fire-related videos [68,69,70]; results are reported in

Table 14. Frame-level detection accuracy on evaluation videos (precision, recall, and F1 score per scene).

Videos	Dataset	Model	Precision (%)	Recall (%)	F1 Score (%)
		YOLOv5n	65.00	45.00	53.41
		YOLOv9t	66.00	46.00	54.38
		YOLOv11n	67.00	48.00	56.08
	Flame	YOLOv12n	67.00	49.00	56.93
		YOLOFM	68.00	49.00	57.55
		YOLO-SAD	68.00	50.00	58.06
Japan VR [68]		YOLOv5n + ESCFM++ (ours)	58.47	59.84	59.15
		YOLOv5n	100.00	44.86	61.93
		YOLOv9t	100.00	40.46	57.61
		YOLOv11n	100.00	40.00	57.14
	Smoke	YOLOv12n	95.00	47.00	62.89
		YOLOFM	94.00	46.00	61.77
		YOLO-SAD	96.00	48.00	64.00
		YOLOv5n + ESCFM-RS (ours)	100.00	50.20	66.84
		YOLOv5n	73.00	69.00	71.00
		YOLOv9t	84.77	86.08	85.42
		YOLOv11n	87.13	88.00	87.56
		YOLOv12n	86.00	85.00	85.50
		YOLOFM	85.50	85.70	85.60
		YOLO-SAD	86.20	86.00	86.10
USA VES [69]		YOLOv5n + ESCFM++ (ours)	67.17	91.75	77.56
		YOLOv5n	88.57	46.27	60.78
		YOLOv9tn	100.00	31.34	47.72
		YOLOv11n	100.00	31.58	48.00
		YOLOv12n	90.00	62.00	73.42
		YOLOFM	89.00	61.00	72.39
		YOLO-SAD	91.00	63.00	74.45
		YOLOv5n + ESCFM-RS (ours)	93.75	67.16	78.26
		YOLOv5n	93.52	70.62	80.48
		YOLOv9tn	96.47	57.34	70.10
		YOLOv11n	98.15	63.10	76.81
		YOLOv12n	95.00	58.20	71.80
		YOLOFM	95.70	59.00	72.55
		YOLO-SAD	96.20	60.10	74.01
USA WSF [70]		YOLOv5n + ESCFM++ (ours)	77.01	93.71	84.54
		YOLOv5n	87.34	67.65	76.24
		YOLOv9tn	96.61	55.88	70.80
		YOLOv11n	97.44	63.33	76.77
		YOLOv12n	90.00	95.00	92.43
		YOLOFM	89.00	94.00	91.43
		YOLO-SAD	91.00	95.00	92.96
		YOLOVv5n + ESCFM-RS (ours)	93.52	99.02	96.19

. On the Japan VR video [68], YOLOv5n achieved the most balanced smoke detection (F1 = 61.9%), whereas the proposed ESCFM-RS improved to 66.8% by reaching 100% precision with moderate recall (50.2%). For flame detection, YOLOv11n obtained the highest F1 score (87.6%), while the proposed ESCFM++ achieved 59.2%, reflecting the challenge of cross-domain flame generalization.

Overall, the proposed detectors remain real-time on edge hardware and generalize competitively, especially for smoke detection, where they attain the best precision–recall balance on challenging real-world footage.

Table 14 shows consistent generalization benefits from the proposed modules across three unseen videos. On Japan-VR, the flame task remains challenging for all baselines (F1 ≈ 53–58%), whereas YOLOv5n + ESCFM++ attains the best F1 (59.15%) by improving recall by 9–15 points compared with YOLOv5n and YOLOv12n. For smoke, YOLOv5n + ESCFM-RS achieves the highest F1 (66.84%) with perfect precision (100%) and improved recall (50.2%), indicating robust confidence calibration for thin and drifting smoke.

On USA-VES, YOLOv11n delivers the strongest flame F1 (87.56%), while ESCFM++ yields the top recall (91.75%), suggesting a better miss rate profile even with lower precision. For smoke, ESCFM-RS provides the best overall F1 (78.26%), outperforming transformer augmented and attention-heavy YOLO variants by 3–6 points.

On USA-WSF, ESCFM++ attains the best flame F1 (84.54%) with a large recall gain (93.71%), and ESCFM-RS establishes a clear state of the art on smoke (F1 = 96.19%), surpassing strong baselines such as YOLO-SAD (92.96%). Overall, the two specialized modules, ESCFM++ for flame and ESCFM-RS for smoke, improve cross-domain robustness primarily through recall amplification without sacrificing precision, aligning with their design goals for small irregular flames and diffuse smoke patterns.

Figure 8 presents qualitative results of the proposed detector on previously unseen fire videos spanning indoor and outdoor scenes. The top row shows Fire Scene VR (indoor), the middle row Vent Enter Search (outdoor, nighttime), and the bottom row Working Structure Fire (outdoor, daytime). For each scenario, flame and smoke detections are visualized separately, indicating that the proposed model generalizes across diverse environments and lighting conditions.

Table 15. Statistical Significance Test Result (Proposed vs. Baselines, mAP@50).

Comparison Pair	T-Statistic	p-Value	Cohen’s d	Significance
YOLOv5n vs. Proposed (Flame, ESCFM++)	4.85	0.003	1.25	Yes
YOLOv5n vs. Proposed (Smoke, ESCFM-RS)	4.42	0.004	1.18	Yes

summarizes the paired t-test results comparing the proposed flame-specific (ESCFM++) and smoke-specific (ESCFM-RS) detectors with the YOLOv5n baseline in terms of mAP@50. For flame detection (YOLOv5n vs. ESCFM++), the t-statistic is 4.85 with a p-value of 0.003, indicating a highly significant improvement at the 0.01 level, and the corresponding Cohen’s d of 1.25 denotes a large effect size. For smoke detection (YOLOv5n vs. ESCFM-RS), the test yields a t-statistic of 4.42 and a p-value of 0.004, again confirming statistical significance, with a Cohen’s d of 1.18 indicating a large effect size. These results demonstrate that the proposed dual-stream detectors (ESCFM++ for flames and ESCFM-RS for smoke) provide statistically reliable and practically meaningful improvements over the YOLOv5n baseline.

As summarized in

Table 16. Detection performance on pure flame samples according to bounding-box area.

Model	BBox Area Ratio	Precision (%)	Recall (%)	F1-Score (%)
YOLOv5n	>15% of image area	100.00	97.86	98.92
YOLOv5n	≤15% of Image area	53.36	54.92	54.13
Proposed	>15% of Image area	100.00	99.15	99.57
Proposed	≤15% of Image area	100.00	37.67	54.72

, both detectors achieve 100.00% precision for large flames whose bounding boxes exceed 15% of the image area, while the proposed model attains higher recall (99.15% vs. 97.86%) and F1-score (99.57% vs. 98.92%) than YOLOv5n, indicating more reliable detection of clearly visible flames. For small flames (≤15% area), YOLOv5n provides a more balanced trade-off between precision and recall (53.36% and 54.92%, respectively; F1-score of 54.13%), whereas the Proposed model adopts a highly conservative behavior with 100.00% precision but substantially lower recall (37.67%), yielding a comparable F1-score of 54.72%. These results suggest that the proposed detector strongly suppresses false positives for small flames at the cost of missing more small flame instances.

Table 17. Detection performance of flame detectors under daytime and nighttime conditions. All values are reported in percent (%).

Model	State	Precision (%)	Recall (%)	F1-Score (%)
YOLOv5n	Daytime	59.89	62.06	60.96
YOLOv5n	Night	67.17	91.75	77.56
Proposed	Daytime	99.31	46.41	63.26
Proposed	Night	77.93	85.57	81.57

compares the flame detection performance of YOLOv5n and the proposed model under daytime and night conditions. During daytime, YOLOv5n exhibits moderately balanced precision and recall (59.89% and 62.06%), resulting in an F1-score of 60.96%. In contrast, the proposed model achieves extremely high precision (99.31%) but substantially lower recall (46.41%), yielding a slightly higher F1-score of 63.26%. This indicates that the proposed flame-specific detector markedly reduces false alarms at the expense of missing more daytime flames. At night, the Proposed model outperforms YOLOv5n in terms of overall balance: it improves precision from 67.17% to 77.93% and achieves a higher F1-score (81.57% vs. 77.56%), while still maintaining a high recall of 85.57% (slightly below the 91.75% of YOLOv5n). These results suggest that the proposed architecture is particularly effective in low-light conditions, delivering a better precision–recall trade-off for nighttime flame detection.

As shown in

Table 18. Detection performance of smoke detectors under daytime and night conditions. All values are reported in percent (%).

Model	State	Precision (%)	Recall (%)	F1-Score (%)
YOLOv5n	Daytime	99.49	49.64	66.23
YOLOv5n	Night	99.12	56.07	71.63
Proposed	Daytime	99.26	48.59	65.24
Proposed	Night	99.03	67.72	80.43

, both smoke detectors maintain near-perfect precision during daytime (99.49% for YOLOv5n and 99.26% for the Proposed model), while their recalls remain around 50%, leading to similar F1-scores (66.23% vs. 65.24%). This indicates that, under daytime conditions, the proposed smoke-specific detector behaves comparably to the baseline. Under night conditions, however, the proposed model substantially improves recall from 56.07% to 67.72%, with only a negligible decrease in precision (99.12% to 99.03%), resulting in a clearly higher F1-score (80.43% vs. 71.63%). Therefore, the proposed smoke-specific architecture provides a pronounced advantage in nighttime smoke detection, capturing more true smoke instances while preserving an extremely low false-positive rate.

4.7. Real-World Outdoor Live-Stream Case Study

We further evaluate our models in a real outdoor live-stream setting by connecting a USB webcam directly to the Jetson Xavier NX. We capture daytime and nighttime videos and run end-to-end inference on the edge device to validate real-time detection of small flames. Quantitative results are summarized in

Table 19. Per-clip performance (%) for real-world small-flame live-stream tests (daytime and nighttime): baseline (YOLOv5n) vs. proposed (YOLOv5n + ESCFM++).

Condition	YOLOv5n Precision (%)	YOLOv5n Recall (%)	YOLOv5n F1 (%)	Proposed Precision (%)	Proposed Recall (%)	Proposed F1 (%)	ΔF1 (p.p.)
Daytime 1	95.77	69.39	80.47	90.29	94.9	92.54	12.06
Daytime 2	92.31	77.42	84.21	89.55	93.75	91.6	7.39
Nighttime 1	100	100	100	100	98.8	99.39	−0.61
Nighttime 2	96.15	97.09	96.62	94.81	97.57	96.17	−0.45

and

Table 20. Macro-averaged Precision, Recall, and F1-score (%) for flame detection under daytime, nighttime, and overall conditions: baseline (YOLOv5n) vs. proposed (YOLOv5n + ESCFM++).

Condition	YOLOv5n Precision (%)	YOLOv5n Recall (%)	YOLOv5n F1 (%)	Proposed Precision (%)	Proposed Recall (%)	Proposed F1 (%)	ΔPrecision (p.p.)	ΔRecall (p.p.)	ΔF1 (p.p.)
Daytime	94.04	73.4	82.34	89.92	94.32	92.07	−4.12	20.92	9.73
Nighttime	98.08	98.54	98.31	97.41	98.18	97.78	−0.67	−0.36	−0.53
Overall	96.06	85.97	90.33	93.66	96.25	94.93	−2.4	10.28	4.6

, and representative qualitative examples are shown in Figure 9. Specifically, we recorded four outdoor video clips (two daytime and two nighttime), each with a duration of 1 min, under a controlled small-flame scenario to safely emulate early-stage flame cues without recreating large-scale fires. This evaluation complements benchmark experiments by verifying that the proposed edge-ready pipeline maintains reliable performance under practical illumination changes (day vs. night) and real-world outdoor background clutter.

Table 19 reports clip-level performance for Daytime1–2 and Nighttime1–2. In daytime conditions, where small flames are more easily confused with background textures, reflections, and illumination variations, the proposed method shows a clear improvement over the baseline. For Daytime1, the F1 score increases from 80.47% (YOLOv5n) to 92.54% (Proposed), corresponding to a +12.06 percentage-point gain, and for Daytime2, the F1 score increases from 84.21% to 91.60%, yielding a +7.39 percentage-point gain. In contrast, nighttime scenes provide higher flame-to-background contrast, making detection easier for both models, and thus the performance gap becomes marginal. For Nighttime1, the F1 score changes from 100.00% to 99.39%, and for Nighttime2, it changes from 96.62% to 96.17%, indicating that both methods achieve near-saturated performance and differences remain small.

Table 20 summarizes the macro-averaged results by lighting condition and overall, clarifying the practical impact of the proposed method in real-time streaming. Under daytime conditions, the proposed method improves recall substantially from 73.40% to 94.32% (+20.92 percentage points), while precision slightly decreases from 94.04% to 89.92% (−4.12 percentage points), resulting in a net F1 improvement from 82.34% to 92.07% (+9.73 percentage points). This trend suggests that the baseline tends to miss weak or tiny flame cues in daytime videos, whereas the proposed method detects small flames more consistently, which is critical for early warning, even at the cost of a modest precision reduction. Under nighttime conditions, both models perform similarly with minimal differences, where the baseline achieves an F1 of 98.31% and the proposed method achieves 97.78%, reflecting the fact that the strong luminance contrast in nighttime scenes reduces ambiguity and diminishes the relative benefit of specialized attention. When aggregating all clips, the proposed method increases overall recall from 85.97% to 96.25% (+10.28 percentage points) and improves overall F1 from 90.33% to 94.93% (+4.60 percentage points), demonstrating that the proposed approach yields a meaningful net gain in end-to-end edge live-stream inference, primarily by improving sensitivity to weak early-stage flame cues in more challenging daytime conditions.

Figure 9 provides representative qualitative comparisons consistent with Table 19 and Table 20. In the top row (daytime), panel (a) Day 1 shows that both YOLOv5n and YOLOv5n+ESCFM++ can produce multiple boxes when the flame is small and distant, indicating that long-range tiny-flame perception under cluttered outdoor backgrounds remains challenging. In panel (b) Day 2, YOLOv5n tends to generate a small off-target box with less consistent localization, whereas YOLOv5n+ESCFM++ places bounding boxes more stably around the true flame region, visually supporting the daytime recall and F1 improvements. In the bottom row (nighttime), panels (a) Night-1 and (b) Night-2 show that both methods detect flames reliably with only minor qualitative differences, consistent with the near-ceiling nighttime performance. Overall, the proposed model’s primary advantage emerges in challenging daytime outdoor scenarios where small-flame cues are weak and easily confounded by background complexity, while nighttime scenes are comparatively easier due to higher contrast, leading to similar performance for both methods.

5. Conclusions

In this work, we presented ESCFM-YOLOv5, a dual-stream detection framework for real-time flame and smoke perception on edge devices. Conventional unified detectors often learn flame and smoke jointly within a single backbone, although the two classes exhibit opposing visual statistics (flames: high luminance and edge-dominant cues; smoke: low-contrast and diffuse patterns). Such joint learning can lead to cross-class feature/gradient interference, where optimizing for edge-dominant flame cues suppresses subtle smoke signals, or optimizing for diffuse smoke cues blurs discriminative flame boundaries. This issue becomes particularly critical in early-warning scenarios, where cues are weak (small flames and thin smoke) and easily confused with background distractors such as reflections, illumination changes, and textured surfaces. To mitigate this limitation, we designed two lightweight specialists, YOLOv5n with ESCFM++ for flames and YOLOv5n with ESCFM-RS for smoke, which are trained and deployed independently to reduce cross-class interference while preserving sensitivity to early-stage cues under strict edge constraints.

Experiments on the D-Fire dataset demonstrate that the proposed lightweight attention modules improve detection performance without increasing the model footprint. For flame-only detection, ESCFM++ enhances mAP@50 while maintaining a compact parameter budget, and statistical tests confirm that the observed improvements are not due to chance. For smoke-only detection, ESCFM-RS achieves competitive performance compared to recent lightweight baselines, providing a practical advantage in terms of the accuracy–efficiency trade-off required for edge deployment.

Beyond offline benchmarks, we further evaluated real-world deployability by performing end-to-end live-stream inference on an outdoor daytime/nighttime setup, where a USB webcam was directly connected to the Jetson Xavier NX (each clip is 1 min long). The quantitative results (Table 19 and Table 20) indicate that the proposed method is particularly beneficial under daytime conditions, where small flames are more easily confused with background textures, reflections, and illumination variations. In these challenging daytime scenes, the proposed method more consistently captures weak early-stage flame cues, resulting in meaningful performance improvements. In contrast, nighttime scenes typically offer higher flame-to-background contrast, making detection easier for both models; thus, the performance gap becomes marginal due to near-saturated accuracy. This trend suggests that the task-specific attention design provides its strongest practical gains under more difficult conditions, especially in daytime scenarios.

Nevertheless, this work has several limitations. First, due to safety, ethical, and facility constraints, we were not able to recreate and evaluate real fire scenarios indoors with extensive environmental variations. Accordingly, our goal was not to reproduce fire itself, but rather to quantitatively validate real-time detectability of early-stage cues using controlled flame sources. To enhance realism under such constraints, we complemented limited indoor feasibility by securing an outdoor location and collecting daytime and nighttime real videos under low-wind conditions, followed by on-device real-time evaluation on the edge platform. Second, in daytime conditions, false alarms still occur due to background patterns (e.g., wall textures, structural edges, and reflections), indicating that additional improvements are needed for reliable operation in diverse real environments. This behavior reflects a common trade-off when increasing sensitivity for early warning, and it should be addressed more systematically.

Future work will extend the evaluation protocol to more diverse outdoor/indoor environments with broader variations in distance, viewpoint, and background. To reduce false alarms caused by textures and reflections, we plan to incorporate hard-negative training (reflection/light-source/textured distractors), temporal consistency modeling, and/or lightweight post-processing stabilization (e.g., track-level confirmation). We will also explore multimodal sensing (e.g., infrared/thermal cameras) to improve robustness across lighting conditions, and, when feasible, expand validation toward operationally realistic scenarios such as structured fire drills and larger-scale field evaluations.