FasterNetFire: A Cost-Effective Fast Neural Network for Forest Fire Detection with Partial Convolution

Abstract

Forest fires occur frequently around the world due to extreme weather conditions of high temperatures and drought. Vision-based convolutional neural networks (CNNs) have greatly improved forest fire detection accuracy. However, slow inference speed severely restricts real-time deployment in actual forest scenes. Existing models generally adopt group convolution (GConv) or depthwise convolution (DWConv) to reduce computational complexity, which causes frequent memory access and result in a practical inference speed far below theoretical expectations. Therefore, we propose a novel fast neural network named FasterNetFire for forest fire detection, which introduces partial convolution (PConv) as the basic feature extraction operator to reduce redundant computation as well as memory access overhead simultaneously. FasterNetFire is composed of four cascaded stages, each stage contains several stacked FasterNet Blocks, and the core of each FasterNet Block is an inverted residual module built upon PConv. The proposed network significantly improves inference efficiency while maintaining the effectiveness of spatial feature extraction. Experiments conducted on the FD and Foggia’s fire detection dataset demonstrate that our FasterNetFire achieves an impressive inference speed of up to 290 frames per second (FPS) on graphics processing unit (GPU) platforms. Compared with current representative methods, its inference speed is 4.5× and 4× faster than that of EFDNet and DFAN. Furthermore, FasterNetFire achieves the best results among 17 state-of-the-art methods, achieving an excellent balance between detection accuracy and real-time response performance. This advantage fully verifies the high efficiency of PConv in vision forest fire detection tasks and provides a novel lightweight solution for real-time monitoring and early warning of forest fires in resource-constrained environments.

1. Introduction

Driven by extremely high-temperature and drought conditions, forest fuels persistently accumulate under extremely dry environments, resulting in frequent forest fires [1,2]. Forest fire is a major sudden-onset disaster that threatens human life and property and severely damages natural ecosystems [2]. Due to its rapid spread, wide impact range, and destructive power, once a fire occurs, it may cause irreversible casualties, substantial economic losses, and long-term ecological damage [3]. To effectively prevent large-scale harm, early, accurate, and real-time fire detection is essential.

For many years, traditional contact sensors such as those for smoke, temperature, and particles were employed for fire detection. Such sensors are inexpensive and easy to deploy. However, they require proximity to the fire source to be activated and manual intervention to verify the authenticity of alarms. Moreover, they cannot provide information regarding the scale and location of a fire, which may result in missing the optimal time for fire extinguishing. To overcome these limitations, researchers have proposed fire detection systems based on visual sensors [4,5]. Such sensors feature fast response, wide coverage and strong environmental robustness, and have attracted increasing attention [6].

Traditional vision methods depend on handcrafted color, texture, and shape features [5,7,8,9]. In complex scenes, such features are sensitive to illumination changes, occlusion, and cluttered backgrounds. Moreover, flame-like objects (e.g., sunset, red light sources, and vehicle lights) exhibit high visual similarity to real fire, leading to poor generalization and high false-alarm rates.

With the success of deep learning in image classification, object detection, and semantic segmentation, fire detection has also made major progress, with representative models, including ANetFire [10], CNNFire [11], ResNetFire [12], GNetFire [13], EMNFire [14], EFDNet [15], IEFDNet [16], and DFAN [17], as shown in Figure 1. ANetFire and CNNFire [10,11] achieve extremely high inference speed by adopting standard convolutions; nevertheless, their model accuracy is below 90%. Both EFDNet and DFAN [15,17] achieve accuracy exceeding 95%, yet their inference speed on GPUs is merely around 70 FPS. Although DFAN_Comp [17] nearly doubles the inference speed of DFAN to 125 FPS, it employs genetic algorithms with high time complexity for channel pruning. By optimizing multi-scale convolutions, IEFDNet [16] improves inference speed but incurs a certain loss in accuracy. Therefore, achieving a better trade-off among fire detection accuracy, inference speed, and model size remains a major challenge in the current field of fire detection. Most existing state-of-the-art (SOTA) models adopt convolution operators such as group convolution [18] (GConv) and depthwise convolution [19] (DWConv). These convolution operators significantly reduce model floating-point operations (FLOPs) and improve accuracy; nevertheless, frequent memory access severely compromises model inference speed.

Beyond fire detection, recent studies also show that efficient learning and optimization models are being actively applied in trajectory segmentation for urban GPS [20], thermal-property inversion for airport pavement materials [21], stochastic aircraft–pavement vibration analysis [22], multi-UAV path planning [23], flight-arrival prediction [24], and facial-video-based affective computing [25]. These cross-domain deployments further motivate pursuing better accuracy–efficiency trade-offs for real-world intelligent systems.

In this paper, we propose a novel network, FasterNetFire, for forest fire detection based on PConv [26], which applies convolution only on a subset of input channels to reduce both computation and memory access. The network contains four stages, each preceded by an Embedding or Merging layer for spatial downsampling and channel expansion. Specifically, the Embedding layer uses a $4\times 4$ convolution with stride 4, while the Merging layer uses a $2\times 2$ convolution with stride 2. Each stage is composed of stacked FasterNet Blocks [26]. Each FasterNet Block contains one PConv layer followed by two pointwise convolution (PWConv, i.e., $1\times 1$ convolution) layers, where the first PWConv expands channels. A shortcut connection is used to reuse input features, forming an overall inverted residual structure.

The main contributions of this study are as follows:

1.

We point out that improving inference speed is a key challenge for current SOTA methods, and that frequent memory access caused by DWConv/GConv-based operators is a major bottleneck.

2.

We introduce PConv, which applies convolution kernels to only a subset of input channels while keeping the remaining channels unchanged, enabling fast and efficient computation. Compared with standard convolution, PConv has lower FLOPs; compared with DWConv/GConv, it achieves higher computational efficiency.

3.

We propose FasterNetFire and evaluate it on the FD dataset, one of the largest and most challenging datasets in fire detection. Experimental results show that FasterNetFire significantly outperforms mainstream methods in detection accuracy, model size, and inference speed. On GPU, our method reaches an impressive 290 FPS on the FD dataset, which is about $4.5\times$ and $4\times$ faster than EFDNet [15] and DFAN [17].

The rest of this paper is organized as follows: Section 2 reviews related work, Section 3 presents the proposed method in detail, Section 4 reports experimental results and analysis, and Section 5 concludes the paper and discusses future work.

2. Related Work

In this section, we briefly review related research on vision-based fire detection, including traditional machine-learning vision detection methods and deep-learning-based detection methods, and clarify the differences between our work and these studies.

2.1. Traditional Machine Learning

Traditional machine-learning fire detection methods mainly rely on extracting color, texture, shape, motion, and other features from input images. Researchers extracted color features in RGB/YCbCr/YUV color spaces to achieve general fire detection. For instance, Healey et al. [7] used class probabilities based on color information for fire detection. Chen et al. [4] proposed extracting flame and smoke pixels using a color model to realize fire detection. Celik et al. [5] proposed a generic fire detection method based on color features in the YCbCr color space. However, this type of detection method, which relies only on color features, has poor robustness and leads to a high false-alarm rate. To solve this problem, Celik et al. [8] introduced a fuzzy-logic system to improve the color model and enhance the model’s ability to distinguish real flames from flame-like targets. Angayarkkani et al. [9] proposed a data-driven forest fire detection method that combines color information with a fuzzy inference system. Some researchers began to apply motion information to fire detection tasks. For example, Toreyin et al. [27] used a hidden Markov model to distinguish real flames from flame-like moving objects, and also used a spatiotemporal wavelet transform to analyze flame dynamics. However, too many heuristic thresholds limited this method in practical applications. Lee et al. [28] proposed a method based on spatiotemporal feature analysis to extract smoke motion features. To extract moving regions more accurately, researchers introduced Gaussian mixture models (GMM) and optical-flow methods. Han et al. [29] and Chen et al. [30] both used GMM to extract moving foreground targets, and then combined other algorithms to determine whether the foreground was flame. Ha et al. [31] used motion vectors to describe dynamic targets, extracted color features in the LAB color space, and combined flame features to identify real fires. However, classical optical-flow algorithms based on the brightness-constancy assumption cannot adequately represent flame appearance. Therefore, Mueller et al. [32] specifically designed two improved optical-flow methods for fire detection: an optimal transport model integrating dynamic texture information and a data-driven optical-flow method. However, due to high computational cost, this type of moving-target extraction method has not been widely used in fire detection. Because heuristic-rule-based methods have limitations in feature extraction, researchers proposed trainable methods with automatic feature-learning capability to avoid subjective factors affecting classification results. For example, Gubbi et al. [33] extracted features through discrete cosine transform and discrete wavelet transform, and then used support vector machines (SVM) for classification. Emmy Prema et al. [34] segmented suspected smoke regions using color filters, extracted features, and then used SVM to classify the extracted features. Byoung et al. [35] extracted high-frequency component magnitudes in horizontal, vertical, and diagonal directions as features, and then used a two-class SVM for final classification. Habiboglu et al. [36] used SVM to classify covariance features extracted from spatiotemporal blocks. Truong et al. [37] used an adaptive Gaussian model to segment moving regions, clustered flame pixels by fuzzy C-means, extracted spatiotemporal features, and then used SVM for feature classification. Yuan [38] combined local binary patterns (LBP) with color features and used AdaBoost to distinguish smoke images from non-smoke images. To enhance discrimination between flames and flame-like targets, Zhang et al. [39] designed a BP neural network based on flame dynamic characteristics for fire detection. Traditional methods based on manually designed features require complex feature engineering and cumbersome pipelines. In addition, maintaining a good balance between detection accuracy and false-alarm rate remains a difficult problem.

2.2. CNN

In recent years, deep learning has made significant progress in computer vision and has been widely applied. In particular, image recognition based on deep convolutional neural networks can automatically perform end-to-end feature extraction and classification, making it more convenient and reliable. To overcome the limitations of traditional vision detection methods, several researchers began to apply existing CNN methods to fire detection tasks. For instance, Frizzi et al. [40] and Mao et al. [41] used LeNet-5 [42] to detect fire, while Sun et al. [43] applied this network to the specific scenario of forest fire detection. Compared with traditional methods based on handcrafted features, CNN-based methods achieved significant improvements in detection accuracy. Lee et al. [44] verified through multiple experiments the performance of GoogLeNet, VGG, and AlexNet for fire detection, among which GoogLeNet performed best. Sharma et al. [12] evaluated VGG16 [45] and ResNet50 [46]; experimental results showed that ResNetFire outperformed VGG16, but the dataset used in the experiments was relatively small. Dunnings et al. [47] compared InceptionV1 [48], VGG16 [45], and AlexNet [18]. On this basis, they simplified the networks to form FireNet and InceptionV1-OnFire. Although the simplified networks reduced classification accuracy by about 1%, inference speed increased by 3 to 4 times. Muhammad et al. [10] proposed AlexNetFire for early fire detection, but the model had too many parameters and was difficult to deploy on resource-constrained devices. To solve this problem, they proposed GNetFire [13] for fire detection in surveillance videos, then designed a lightweight CNNFire [11] network for fire detection in surveillance videos, and proposed EMNFire [14] for fire detection in IoT environments with complex uncertainty. In recent studies, they further expanded related auxiliary tasks, including human detection and counting, evacuation monitoring, combustible-object detection, and target-type recognition [49]. Existing CNN-based fire detection methods have achieved significant progress, but they have not effectively balanced detection accuracy and model complexity. To reduce CNN architectural complexity, Li et al. proposed EFDNet [15], which integrated AlexNet, Inception modules, and an implicit deep-supervision module. DFAN [17] applied a dual fire attention network for efficient and accurate fire detection. MS-Net [50] proposed a fire detection method that can handle variable-scale images. Although these networks improved fire detection accuracy and reduced computational complexity and model size, inference speed is equally important as recognition accuracy in practical deployment scenarios. Existing models have still not achieved a new breakthrough in inference speed, which greatly limits their deployment on resource-constrained devices.

3. Methodology

As illustrated in Figure 2, FasterNetFire adopts a four-stage hierarchical backbone. The input image is first processed by an embedding layer for initial downsampling and channel projection, and then passed through consecutive stages with progressively increased channel width. Each stage stacks several FasterNet blocks, where a PConv layer performs efficient spatial feature extraction and two pointwise ($1\times 1$) convolutions complete channel mixing and transformation. This design preserves discriminative fire features while reducing computational overhead.

3.1. Partial Convolution

For fire/non-fire classification, we need operators that preserve discriminative flame cues while limiting per-layer computation and memory traffic. PConv [26] achieves this by applying a $k\times k$ spatial kernel only to a fraction of input channels and forwarding the remaining channels without spatial convolution, instead of touching every channel with depthwise or grouped kernels at each step.

Given a feature map $\mathbf{X}\in {\mathbb{R}}^{h\times w\times c}$, where h and w are spatial height and width, c is the number of channels, and $r\in (0,1]$ is a partial ratio, the number of channels that participate in spatial mixing is

$$c_p=max\left(1,\lfloor rc\rfloor \right).$$

(1)

We partition $\mathbf{X}$ along the channel axis into ${\mathbf{X}}_1\in {\mathbb{R}}^{h\times w\times c_p}$ and ${\mathbf{X}}_2\in {\mathbb{R}}^{h\times w\times (c-c_p)}$, i.e., the partial slice to be convolved and the identity slice that bypasses the $k\times k$ operator, respectively. Only ${\mathbf{X}}_1$ is passed through a standard convolution with kernel size k, stride s, padding p, and parameters $\theta$; ${\mathbf{X}}_2$ is carried forward unchanged until the two slices are merged. The forward mapping of PConv is, therefore,

$$\begin{array}{cc}\hfill {\mathbf{Y}}_1& ={\mathrm{Conv}}_{k\times k}({\mathbf{X}}_1;\theta ),\hfill \\ \hfill \mathbf{Y}& =\mathrm{Concat}({\mathbf{Y}}_1,{\mathbf{X}}_2)\in {\mathbb{R}}^{h\prime \times w\prime \times c},\hfill \end{array}$$

(2)

where ${\mathrm{Conv}}_{k\times k}(·;\theta )$ denotes the $k\times k$ convolution on ${\mathbf{X}}_1$, $\mathrm{Concat}(·,·)$ stacks tensors along the channel dimension, and $(h\prime ,w\prime )$ is the spatial size induced by $(k,s,p)$. Stride and padding are chosen consistently with the backbone so that ${\mathbf{Y}}_1$ and ${\mathbf{X}}_2$ stay spatially aligned before concatenation. Intuitively, $c_p$ controls how aggressively spatial context is extracted, while the $c-c_p$ identity channels retain low-cost cues (e.g., color layout of fire-like distractors) without extra $k\times k$ multiply–accumulates on the full width [26].

3.2. FasterNetBlock

A FasterNet block is the elementary residual-style unit in our backbone [26]: it performs inexpensive spatial mixing on a channel subset via PConv, then performs full cross-channel fusion with a pointwise ($1\times 1$) convolution, batch normalization, and a nonlinearity. Thus, spatial context is first injected on a partial channel slice, and channel interaction is completed afterward at full width—a compact pattern suited to lightweight backbones.

Let $\mathbf{X}\in {\mathbb{R}}^{h\times w\times c}$ denote the block input. Partial convolution with ratio r and spatial parameters $(k,s,p,\theta )$ maps $\mathbf{X}$ to an intermediate tensor $\mathbf{U}$ of the same channel width c, following (2). A pointwise convolution with weights ${\mathbf{W}}_{\mathrm{pw}}$ then mixes information across all channels, producing $\mathbf{V}$. Batch normalization with learnable scale and shift $(\gamma ,\beta )$ and an element-wise activation $\sigma (·)$ yields the block output $\mathbf{Y}$. Formally,

$$\begin{array}{cc}\hfill \mathbf{U}& =\mathrm{PConv}(\mathbf{X};r,k,s,p,\theta ),\hfill \\ \hfill \mathbf{V}& =\mathrm{PWConv}(\mathbf{U};{\mathbf{W}}_{\mathrm{pw}}),\hfill \\ \hfill \mathbf{Y}& =\sigma \left(\mathrm{BN}(\mathbf{V};\gamma ,\beta )\right),\hfill \end{array}$$

(3)

where $\mathrm{PWConv}(·)$ denotes $1\times 1$ convolution over the full c channels, $\mathrm{BN}(·)$ applies per-channel normalization with running statistics at inference time, and $\mathbf{U}$, $\mathbf{V}$, and $\mathbf{Y}$ share the spatial size $(h_{\mathrm{b}},w_{\mathrm{b}})$ whenever PConv uses stride one with padding that preserves resolution inside a stage. Any residual wiring used in the concrete FasterNet instantiations [26] is absorbed into the same operator ordering and is not expanded separately in (3).

3.3. FasterNetFire Network

We now assemble PConv and FasterNet blocks [26] into an end-to-end fire–non-fire classifier, denoted FasterNetFire, using the four-stage layout in Figure 2. The architecture follows a standard recipe for image-level binary classification: a compact backbone maps each RGB frame to deep features, and a small head maps pooled features to class logits.

Let $\mathbf{I}\in {\mathbb{R}}^{h_{\mathrm{in}}\times w_{\mathrm{in}}\times 3}$ denote an input RGB image. A stem embedding ${\varphi }_{\mathrm{emb}}(·)$ performs an initial $4\times 4$ convolution with stride 4 and 64 output channels, reducing spatial resolution while expanding channels so that subsequent stages operate on semantically richer tokens:

$${\mathbf{Z}}^{\left(0\right)}={\varphi }_{\mathrm{emb}}\left(\mathbf{I}\right)={\mathrm{Conv}}_{4\times 4,s=4}\left(\mathbf{I};{\mathbf{W}}_{\mathrm{emb}}\right),{\mathbf{W}}_{\mathrm{emb}}\in {\mathbb{R}}^{4\times 4\times 3\times 64}.$$

(4)

The backbone is organized into $L=4$ stages indexed by ℓ $\in \{1,\dots ,4\}$. Stage ℓ stacks N_ℓ FasterNet blocks (3) with a fixed partial ratio r across the network; we denote the composition of these blocks by ${\mathcal{B}}^{\left(\mathcal{l}\right)}(·)$. Between consecutive stages, a transition operator ${\mathcal{S}}^{\left(\mathcal{l}\right)}(·)$ adjusts spatial size and channel width (“merging” in the FasterNet terminology [26]) so that deeper stages see coarser maps with wider representations:

$${\mathcal{S}}^{\left(\mathcal{l}\right)}\left({\mathbf{X}}^{\left(\mathcal{l}\right)}\right)={\mathrm{Conv}}_{2\times 2,s=2}\left({\mathbf{X}}^{\left(\mathcal{l}\right)};{\mathbf{W}}_{\mathrm{merge}}^{\left(\mathcal{l}\right)}\right),{\mathbf{W}}_{\mathrm{merge}}^{\left(\mathcal{l}\right)}\in {\mathbb{R}}^{2\times 2\times c_{\mathcal{l}-1}\times c_{\mathcal{l}}}.$$

(5)

In our training configuration, $(N_1,\dots ,N_4)=(1,2,8,2)$ and $(c_1,\dots ,c_4)=(64,128,256,512)$ channels after each stage transition, consistent with Table 3. Using the embedding and merging definitions in Equations (4) and (5), the recursive feature extraction pipeline can be written as

$$\begin{array}{cc}\hfill {\mathbf{Z}}^{\left(0\right)}& ={\varphi }_{\mathrm{emb}}\left(\mathbf{I}\right),\hfill \\ \hfill {\mathbf{Z}}^{\left(\mathcal{l}\right)}& ={\mathcal{S}}^{\left(\mathcal{l}\right)}\left({\mathcal{B}}^{\left(\mathcal{l}\right)}\left({\mathbf{Z}}^{(\mathcal{l}-1)}\right)\right),\mathcal{l}=1,\dots ,4,\hfill \end{array}$$

(6)

where ${\mathbf{Z}}^{\left(\mathcal{l}\right)}$ is the output tensor of stage ℓ, ${\mathbf{Z}}^{\left(0\right)}$ is the stem feature, and ${\mathbf{Z}}^{\left(4\right)}$ is the deepest map fed to the classifier.

For binary fire detection, we apply global average pooling (GAP) over the spatial dimensions of ${\mathbf{Z}}^{\left(4\right)}$ and attach a linear layer with weights $\mathbf{W}$ and bias $\mathbf{b}$, followed by a softmax to obtain class probabilities $\widehat{\mathbf{p}}\in {\mathbb{R}}^2$:

$$\widehat{\mathbf{p}}=\mathrm{softmax}\left(\mathbf{W}\mathrm{GAP}\left({\mathbf{Z}}^{\left(4\right)}\right)+\mathbf{b}\right).$$

(7)

Here $\mathrm{GAP}(·)$ outputs a $c_4$-dimensional vector by averaging each channel of ${\mathbf{Z}}^{\left(4\right)}$ over its spatial grid, $\mathbf{W}\in {\mathbb{R}}^{2\times c_4}$, and the j-th entry of $\widehat{\mathbf{p}}$ is interpreted as the predicted probability of class j (fire vs. non-fire).

4. Experimental Results

4.1. Experimental Setup

4.1.1. Dataset

In this paper, experiments are conducted on both the FD dataset [15] and Foggia’s dataset [6]. These two benchmarks provide complementary evaluation for image-based and video-sequence-based fire detection scenarios.

The FD dataset is currently a widely used public benchmark dataset in fire detection, with abundant samples and high scene complexity, and is specifically designed to validate flame recognition and anti-interference capability of models in complex environments. This dataset is a balanced binary-class dataset, containing two major categories: Fire and Non-Fire. The samples cover multiple real environments, including indoor, outdoor, forest, building, and traffic scenes, as shown in Figure 3. It also contains a large number of flame-like interference samples that are highly similar to flames in color and brightness, such as sunsets, evening glow, strong light, red lights, red vehicles, red tents, and lanterns, which can fully evaluate the model’s feature discrimination ability and generalization performance. The dataset is split into training, validation, and test sets according to a fixed ratio, and all subsets maintain a balanced class distribution. The detailed sample numbers are shown in

Table 1. The detailed statistics of training, validation and testing set of the FD dataset.

Dataset	Fire	Non Fire	Total
Training set	17,500	17,500	35,000
Validation set	5000	5000	10,000
Testing set	2500	2500	5000
Total	25,000	25,000	50,000

. The Fire category includes flame samples with different scales, different shapes, and different occlusion levels, covering various cases such as large-area open flames at close range, medium-distance flames, small flames in long-range views, and flames accompanied by smoke. The Non-Fire category contains a large number of flame-like interference samples that are prone to misclassification, which is a key component for evaluating model robustness. The dataset has a large scale, balanced distribution, and complex scenes, which ensures the objectivity, reliability, and reproducibility of experimental results, and meets current research and evaluation standards for deep-learning-based fire detection.

Foggia’s dataset is a video-based fire detection dataset developed by Foggia et al. [6]. This dataset consists of 31 videos, where 14 videos contain fire scenes and 17 videos do not contain fire scenes. Following the frame-extraction protocol adopted in prior studies, we extracted 14,036 frames from these videos and organized them into Fire and Non-Fire classes, with 7018 frames per class. The dataset is further divided into training, validation, and test sets with a ratio of 7:2:1.

4.1.2. Implementation Details

To ensure fairness and reproducibility of experimental results, all comparative experiments, ablation experiments, and parameter analysis experiments in this study are conducted under a unified software and hardware environment, as summarized in

Table 2. Experimental software, hardware environments and training hyperparameters.

Name	Value
Operating system	Ubuntu 22.04.3 LTS
Programming language	Python 3.8.10
Deep learning framework	PyTorch 1.11.0
CUDA Version	12.2
GPU	NVIDIA A100-SXM4-80 GB
CPU	Intel Xeon Gold 6330
RAM	80 GB
Video memory	12 GB
Optimizer	Adam
Initial LR	$5\times {10}^{-4}$
Weight decay	$1\times {10}^{-5}$
LR schedule	Cosine annealing
Training epochs	300

. The hardware platform adopts dual Intel Xeon Gold 6330 central processing unit (CPU) processors with a total of 112 threads, equipped with large-capacity L3 cache and a high-speed memory architecture. It is paired with an NVIDIA A100-SXM4-80GB high-performance computing GPU to provide strong computing support for model training and inference. The software environment is based on Ubuntu 22.04.3 LTS (Jammy Jellyfish), uses CUDA 12.2 for GPU acceleration, and adopts PyTorch 1.11.0 as the deep learning framework. The Raspberry Pi benchmark is conducted on a Raspberry Pi 4 Model B with 4 GB LPDDR4 RAM and a quad-core 64-bit Cortex-A72 CPU at 1.5 GHz. In both training and testing stages, a unified batch size of 32 is used, and the model input image size is fixed at $224\times 224\times 3$, ensuring fair evaluation of all models under the same hardware load and computational conditions.

FasterNetFire is based on FasterNet-T0 [26], with fine-tuning of channel width, block number, and downsampling strategy for the fire-detection task. The specific structural configuration is shown in

Table 3. The outline of our FasterNetFire architecture.

Type	Patch Size/Stride or Remarks	Input Size
Embedding	$4\times 4$ / 4	$224\times 224\times 3$
$1\times$ FasterNet Block	$3\times 3$ / 1	$56\times 56\times 64$
Merging	$2\times 2$ / 2	$56\times 56\times 64$
$2\times$ FasterNet Block	$3\times 3$ / 1	$28\times 28\times 128$
Merging	$2\times 2$ / 2	$28\times 28\times 128$
$8\times$ FasterNet Block	$3\times 3$ / 1	$14\times 14\times 256$
Merging	$2\times 2$ / 2	$14\times 14\times 256$
$2\times$ FasterNet Block	$3\times 3$ / 1	$7\times 7\times 512$
AdaptiveAvgPool2d	$1\times 1$	$7\times 7\times 512$
Flatten	–	$1\times 1\times 1280$
$1\times 1$ Conv	$1\times 1$ / 1	$1\times 1\times 1280$
Linear	Logits	$1\times 1\times 1280$
Softmax	Classifier	$1\times 1\times 2$

, which gives the corresponding tensor shapes when the input resolution is $224\times 224\times 3$.

4.1.3. Evaluation Metrics

In fire detection field, the common evaluation metrics include Recall [51], Precision [51], Accuracy [51], $F_1$-score [52], area under the curve (AUC) [53], and false alarm rate (FAR) [54]. The specific description is shown as follows.

Let true positive (TP), true negative (TN), false positive (FP), and false negative (FN) denote the four entries in the confusion matrix, respectively.

$$\mathrm{Accuracy}={\displaystyle \frac{TP+TN}{TP+TN+FP+FN}}$$

(8)

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

(9)

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

(10)

$$F_1-\mathrm{score}={\displaystyle \frac{2\times \mathrm{Precision}\times \mathrm{Recall}}{\mathrm{Precision}+\mathrm{Recall}}}$$

(11)

$$\mathrm{FAR}={\displaystyle \frac{FP}{FP+TN}}$$

(12)

where $TP$ is the number of true positives, $TN$ is true negatives, $FP$ is false positives, and $FN$ is false negatives. These six metrics jointly characterize model performance from complementary perspectives. Accuracy reflects overall correctness on all samples, while Precision measures the reliability of positive (fire) predictions by penalizing false alarms. Recall quantifies the ability to capture real fire events and is directly related to missed detections, which is especially critical in safety-oriented applications. The $F_1$-score provides a balanced summary of Precision and Recall, enabling robust comparison when the costs of false positives and false negatives must be considered simultaneously. FAR directly measures false alarms over all negative samples, which is important for practical alarm systems. AUC evaluates the ranking quality across all classification thresholds and thus reflects threshold-independent discrimination ability.

4.2. Performance of FasterNetFire

Table 4. Comparison of the performance of state-of-the-art methods on the FD and Foggia’s datasets. The best and second-best methods are highlighted in bold and underline.

Networks	FD Dataset				Foggia’s Dataset
	Precision	Recall	F1-Score	Accuracy	FP	FN	ACC
FD-GCM [5]	63.90	90.00	74.70	69.60	29.41	0	83.87
FFD-ANN [39]	71.10	73.20	72.10	71.70	.	.	.
FPC [8]	52.00	99.90	68.40	53.90	.	.	.
SqueezeNet [55]	90.52	93.62	92.03	91.90	.	.	.
ANetFire [10]	83.30	93.20	87.90	87.20	9.07	2.13	94.39
CNNFire [11]	84.60	91.30	87.90	87.30	8.87	2.12	94.50
GoogLeNet [13]	88.00	98.00	92.73	92.32	.	.	.
MobileNet [56]	91.45	93.71	92.53	92.40	.	.	.
GNetFire [13]	88.00	98.00	92.80	92.30	0.054	1.50	94.43
EMNFire [14]	88.30	98.70	93.20	92.80	0	0.14	95.86
ResNetFire [12]	84.80	97.60	90.00	90.07	.	.	.
ResNet-50 [57]	84.82	97.57	90.74	90.00	.	.	.
EFDNet [15]	93.50	97.40	95.40	95.30	.	.	.
DFAN [17]	96.00	97.00	96.00	96.17	0	0.58	99.60
DFAN_Comp [17]	95.50	96.30	95.90	95.70	0	0.63	99.47
IEFDNet [16]	92.93	97.80	95.30	95.18	.	.	.
ViT-B/32 [58]	92.36	92.18	92.18	92.19	2.15	1.02	94.03
FasterNetFire	94.69	98.32	96.47	96.18 ± 0.50	0.12	0	99.66 ± 0.22

reports the comparative performance of different methods on the FD and Foggia’s datasets. For Foggia’s dataset, only the results reported by the original papers are listed, and missing entries are kept as blanks for fair comparison. Traditional machine-learning methods (FD-GCM [5], FFD-ANN [39], and FPC [8]) are overall significantly weaker than deep-learning methods in terms of accuracy-related performance on the FD dataset. Although FPC achieves the highest recall of 99.90%, its precision and accuracy are only 52.00% and 53.90%, respectively, indicating a severe false-alarm problem. Among deep-learning methods, FasterNetFire achieves 94.69% precision, 98.32% recall, 96.47% F1-score, and $96.18\pm 0.50$% accuracy, with all metrics at a leading level. In particular, both precision and accuracy surpass the current SOTA model DFAN [17] (96.00% and 96.17%), demonstrating a clear breakthrough in overall detection accuracy. On the FD test set, using the confusion-matrix statistics ($TP=2459$, $FP=138$, $FN=42$, $TN=2361$), FasterNetFire further achieves a FAR of $FP/(FP+TN)=138/(138+2361)=5.52\%$, and the corresponding single-operating-point AUC (computed from TPR/FPR) is approximately 96.40%. Over 10 repeated runs, our accuracy is $96.18\pm 0.50$ on FD and $99.80\pm 0.22$ on Foggia’s dataset. More importantly, the model keeps competitive and stable performance across two datasets with different data-collection protocols and scene distributions, including complex illumination conditions (e.g., strong light, sunset-like glow, and nighttime low-light) and highly cluttered backgrounds. This cross-dataset consistency indicates that FasterNetFire learns transferable fire semantics rather than dataset-specific shortcuts, and therefore, does not exhibit single-dataset overfitting. In addition, Foggia’s benchmark is constructed from video sequences, and our strong FP/FN and ACC results on this benchmark further verify the model’s generalization ability and temporal-scene robustness for practical video-surveillance applications.

4.3. Analysis of Model Complexity

Table 5. Comparison of time complexity, model size and FLOPs on the FD dataset. The best and second-best methods are highlighted in bold and underline.

Model	Accuracy	FLOPs (G)	Size (MB)	GPU (FPS)	CPU (FPS)	Pi (FPS)
ANetFire [10]	87.20	.	.	382.0	18.1	.
CNNFire [14]	87.30	.	.	135.9	14.2	.
GNetFire [13]	92.30	1.5	43.30	48.2	4.3	.
EMNFire [14]	92.80	0.3	13.00	61.2	2.4	.
ResNetFire [12]	90.07	3.8	98.00	57.3	2.4	.
EFDNet [15]	95.30	1.13	4.80	63.5	3.0	.
DFAN [17]	96.17	0.141	80.63	70.55	12.90	0.83
DFAN_Comp [17]	95.70	0.073	41.09	125.33	22.73	3.21
IEFDNet [16]	95.18	1.11	2.69	118.80	4.90	.
FasterNetFire	96.18 ± 0.50	0.85	6.32	290.54	38.11	8.44

presents a comparison of FLOPs, model size, and inference speed among deep-learning models. While maintaining a high accuracy of $96.18\pm 0.50$%, FasterNetFire achieves 290.54 FPS on GPU and 38.11 FPS on CPU, significantly outperforming all comparison models in inference speed. On edge-device deployment, FasterNetFire also reaches 8.44 FPS on Raspberry Pi, clearly higher than DFAN (0.83 FPS) and DFAN_Comp (3.21 FPS), showing superior practical responsiveness under constrained hardware. Although the absolute accuracy gain over the strongest baseline is only 0.23%, this margin is still meaningful in safety-critical fire detection, where even a small reduction in misclassification can directly reduce missed alarms and false dispatches in long-term deployment. More importantly, the primary contribution of this work is efficiency-oriented optimization: under nearly the same accuracy level, FasterNetFire delivers about 2–4.5× faster inference than representative high-accuracy baselines, which substantially improves real-time responsiveness and practical deployability on resource-constrained platforms. Figure 4 plots the same quantities in a radial-bar form, so that cross-model contrasts in accuracy, FLOPs, model size, and GPU/CPU/Pi FPS can be read at a glance and checked against Table 5. At the same time, FasterNetFire remains lightweight, with only 6.32 MB model size and 0.85 G FLOPs, demonstrating the best overall balance between detection accuracy and computational efficiency.

4.4. Analysis of Partial Ratio r

Table 6. The performance of different partial ratio r of PConv on the FD dataset. The best and second-best methods are highlighted in bold and underline.

Partial Ratio r	Precision	Recall	F1-Score	Accuracy
1	89.15	90.40	89.77	89.70
$1/2$	89.58	90.44	90.01	89.92
$1/4$	94.69	98.32	96.47	96.40
$1/8$	87.49	86.33	86.91	86.67
$1/16$	86.37	84.50	85.42	85.11
$1/32$	83.30	80.77	82.02	81.57

reports an ablation study on different partial-convolution ratios r in PConv. The model achieves the best overall performance at $r=1/4$, where all metrics reach their peak values. As r decreases ($1/8$, $1/16$, $1/32$), detection performance consistently drops. When r increases to $1/2$, model accuracy also degrades notably, verifying that $r=1/4$ is the optimal configuration for the fire-detection task. To further explain why $r=1/4$ yields the best trade-off in Table 6, we analyze PConv from a memory-access perspective and compare it with commonly used convolution designs in prior fire-detection backbones.

In previous SOTA models, efficiency is often improved by reducing model FLOPs. For example, ResNetFire [12] mainly uses group convolution, EMNFire [14] mainly uses depthwise separable convolution, and GNetFire/EFDNet [13,15] extensively use Inception-style multi-branch structures. These designs reduce FLOPs to some extent, but from the perspective of memory access, the increased memory-access overhead often dominates runtime and can even prevent practical inference speed from improving. Let the input be $\mathbf{X}\in {\mathbb{R}}^{c\times h\times w}$, the output channels be c, the kernel size be $k\times k$, and let group convolution split channels into g groups (each group has $c/g$ channels). Its memory access can be written as follows:

$${\mathrm{MAC}}_{\mathrm{Group}}=h\times w\times 2c+k^2\times {\displaystyle \frac{c^2}{g}}.$$

(13)

As g increases, per-group computation becomes smaller, but data fragmentation across groups reduces cache hit rate and adds extra data transfer between memory and registers, further amplifying memory-access bottlenecks.

To compensate for accuracy loss, depthwise separable convolution is usually combined with channel expansion ($c\to c\prime ,c\prime >c$, e.g., $\times 6$ in MobileNetV2 [59]), and its memory access gradually increases to the following:

$${\mathrm{MAC}}_{\mathrm{DW}+\mathrm{PW}}\approx h\times w\times 2c\prime +k^2\times c\prime \approx h\times w\times 2c\prime .$$

(14)

Here, the term $h\times w\times 2c\prime$ is an I/O bottleneck that is difficult to optimize further and directly increases inference latency.

For Inception-style multi-branch structures, branch outputs are concatenated after parallel computation. Assume there are b branches, and the output channels of each branch are $c_i$ with ${\sum }_i{c}_i=c$. Then memory access is as follows:

$${\mathrm{MAC}}_{\mathrm{Inception}}=h\times w\times 2c+{\displaystyle \sum _{i=1}^b}\left(h\times w\times c_i+{\mathrm{MAC}}_{\mathrm{branch},i}\right).$$

(15)

Compared with standard convolution, the extra term ${\sum }_{i=1}^b(h\times w\times c_i+{\mathrm{MAC}}_{\mathrm{branch},i})$ introduces significant overhead, causing obvious inference slowdown and making the accuracy gain costly.

In contrast, the memory access of PConv is as follows:

$${\mathrm{MAC}}_{\mathrm{PConv}}=h\times w\times 2c+k^2\times {\left(rc\right)}^2,0<r<1,$$

(16)

where r is the ratio of channels participating in spatial convolution to all channels.

4.5. Analysis of Confusion Matrix

By jointly analyzing Table 4 and Table 5, the core advantage of FasterNetFire is a dual breakthrough in both accuracy and efficiency on the FD dataset. On one hand, with a PConv-based high-compute-density feature extraction design, the model substantially reduces computation and parameter size while preserving the key discriminative fire features, and thus achieves superior accuracy to existing SOTA models. This result validates the effectiveness of PConv for fire detection. On the other hand, the partial-channel convolution mechanism in PConv significantly reduces memory-access cost, enabling much higher inference speed on both GPU and CPU while maintaining a lightweight model size, which makes FasterNetFire highly suitable for edge deployment. The ablation study in Table 6 further shows that fire feature maps contain considerable channel redundancy. When r is too small, the model cannot extract sufficient effective features, leading to accuracy degradation. When r is too large, redundant computation increases, which fails to improve accuracy and may reduce inference efficiency. The optimal setting $r=1/4$ strongly confirms the rationality of the PConv design in exploiting feature redundancy and balancing efficiency with accuracy. Overall, FasterNetFire demonstrates clear advantages in accuracy, speed, and parameter size, addressing the long-standing trade-off between high accuracy and high speed in fire detection, and providing an effective solution for real-time and lightweight deployment.

As shown in Figure 5, among 2500 true non-fire samples, 138 are misclassified as fire, yielding a false-alarm rate of 5.52%; among 2500 true fire samples, 42 are missed, yielding a miss-detection rate of 1.68%.

As shown in Figure 6, FasterNetFire keeps both false positives (FP) and false negatives (FN) at very low levels, indicating excellent overall classification performance and satisfying the safety-oriented requirement in fire detection that controlling missed detections is critical while false alarms are acceptable to some extent. The clear score boundary, where TP samples are concentrated above 0.8 and TN samples are concentrated below 0.2, further confirms high classification confidence and a stable decision boundary. As shown in Figure 7, false-positive cases are mainly sunset glow, red vehicles, and strong illumination scenes that are highly similar to real flames in visual appearance. This suggests that the model assigns relatively high response weights to color and brightness cues during feature extraction, making it difficult to distinguish semantic differences between flame-like interference and true fire, which is the primary cause of false alarms. In contrast, false-negative cases are concentrated in small-scale, low-light, and occluded flame scenarios. For smoke-only scenes without clearly visible flames, the current flame-centric visual cues are often insufficient, so such samples are more likely to be predicted as non-fire. Nighttime fires and very small fire sources also remain challenging because weak illumination and limited flame pixels reduce discriminative feature responses. For these extreme conditions, the model is less capable of capturing weak discriminative cues and cannot reliably extract subtle flame features from complex backgrounds, which leads to missed detections. In summary, both the number of FP/FN samples and their error distributions are limited and pattern-consistent, with no evidence of large-scale random misclassification, indicating strong classification stability and good generalization on the FD test set. While substantially reducing computation and improving inference speed, the PConv-based design still preserves core fire-discriminative features, resulting in a low miss-detection rate of only 1.68% and high-confidence correct recognition for most fire samples, which validates its effectiveness and rationality for fire-feature extraction. Meanwhile, the 5.52% false-alarm cases are all explainable flame-like interference samples, rather than random errors.

5. Conclusions

In this paper, we investigated a common limitation of deep learning models for forest fire detection, namely, slow inference speed. Our analysis indicates that a major cause is the frequent memory access introduced by DWConv/GConv operators. To address this issue, we introduced PConv as the basic operator and proposed FasterNetFire. Experimental results on the highly challenging FD dataset show that FasterNetFire achieves the best trade-off between detection accuracy, model size, and inference speed. Considering that about 70% of false alarms in the test set come from flame-like samples (e.g., sunset and red clouds), these interference samples are highly similar to real flames in shallow cues such as color, texture, and brightness. Future work will reduce false alarms by integrating temporal and complementary spectral/modal cues, introducing spatial-attention mechanisms, and exploring privacy-preserving cross-site collaborative training [60,61]. This is expected to improve practical deployment in forest watchtowers, UAV patrol systems, and edge-camera early-warning pipelines while reducing environmental and ecological losses through earlier fire discovery. In practical emergency-management workflows, this can support earlier dispatch decisions and reduce unnecessary patrol and suppression costs caused by delayed or unstable alarms. From an environmental perspective, improving early-stage detection reliability can also help limit secondary emissions and post-fire restoration burdens by preventing small ignitions from escalating into large-scale fires.