Fire-Residual Module: Deep Models & Fire Spread

• Fire-Residual module is a neural network block that merges SqueezeNet’s channel-compression with ResNet’s skip connections to enhance both efficiency and accuracy.
• It employs a squeeze operation, parallel expand convolutions, and conditional residual projections to reduce parameter counts while maintaining representational power.
• In wildfire modeling, the FR module framework minimizes discrepancies between simulated and observed fire perimeters, ensuring physically consistent fire spread assimilation.

A Fire-Residual (FR) module is a neural network architectural building block that combines the channel-compression schemes of SqueezeNet's "Fire module" with the skip connections of ResNet. In other scientific contexts, notably wildfire modeling, 'Fire-Residual module' designates a computational framework that minimizes the residual between physical constraints and observed or simulated fire perimeters. The following entry provides a comprehensive account, with explicit architectural, mathematical, algorithmic, and empirical detail, as documented in the deep learning and wildfire modeling literature.

1. Architectural Definition: Deep Learning FR Module

The deep learning Fire-Residual module is fundamentally a composition of a SqueezeNet "Fire" block and a residual addition. The canonical instance accepts an input tensor $X \in \mathbb{R}^{H \times W \times C}$, applies a bottleneck (squeeze) convolution, parallel expand convolutions, and rejoins the result with the original input. All convolutions are followed by batch normalization, and activations are LeakyReLU or ReLU depending on the implementation (Oh et al., 2020, Qassim et al., 2017).

Block Structure (as in (Oh et al., 2020)):

1. Squeeze: $1 \times 1$ convolution, $C \rightarrow s$ channels.
2. Expand: Two parallel branches:
   • $1 \times 1$ convolution, $s \rightarrow e_1$.
   • $3 \times 3$ convolution (padding=1), $s \rightarrow e_3$.
3. Concatenation: Channel-wise, yielding $(e_1 + e_3)$ output channels.
4. Residual Skip Connection: Elementwise addition of $X$ and the concatenated expand output when $C = e_1 + e_3$ (no projection required; if dimensions mismatch, a $1\times 1$ projection is used (Qassim et al., 2017)).
5. Output: $Y = X + \mathrm{Concat}(E_1(S(X)), E_3(S(X)))$.

Typical Channel Dimension Choices (Oh et al., 2020):

• $e_1 = e_3 = C / 2$ (even split).
• $s = C / 2^k$, optimal $k=4$ ("FRDet16" case: $s = C/16$).

2. Mathematical Formalism

Let $\sigma(\cdot)$ denote a LeakyReLU or ReLU nonlinearity, and $*$ denote convolution. The main transforms are:

$$\begin{align*} S(X) &= \sigma(\mathrm{BN}(W_s * X + b_s)),\quad W_s \in \mathbb{R}^{s \times C \times 1 \times 1} \ E_1(S) &= \sigma(\mathrm{BN}(W_{e1} * S + b_{e1})),\quad W_{e1} \in \mathbb{R}^{e_1 \times s \times 1 \times 1} \ E_3(S) &= \sigma(\mathrm{BN}(W_{e3} * S + b_{e3})),\quad W_{e3} \in \mathbb{R}^{e_3 \times s \times 3 \times 3} \ Y &= X + \mathrm{Concat}[E_1(S),\, E_3(S)] \ \end{align*}$$

If $e_1+e_3 \neq C$, a $1 \times 1$ conv projection with BatchNorm is inserted in the residual path to align dimensions (Qassim et al., 2017).

3. Algorithmic and Implementation Characteristics

Implementations are designed for deep learning frameworks (e.g., PyTorch), follow the pattern above, and emphasize efficiency (Oh et al., 2020). Typical details:

• Squeeze convolution: $1 \times 1$, reduces channels.
• Expand convolutions: one $1 \times 1$, one $3 \times 3$ (both after squeeze).
• Activation: LeakyReLU (slope=0.1) or ReLU.
• Normalization: BatchNorm post-convolution.
• Residual addition: Elementwise channel addition, conditionally with projection.
• Parameter Counts: Squeeze ratio $k$ tuned for $s = C / 2^k$; $k=4$ yielded optimal mAP-size tradeoff.
• Sample PyTorch-style module (Oh et al., 2020):

  class FRModule(nn.Module): def __init__(self, in_ch, k=4): super().__init__() s = in_ch // (2**k) e1 = e3 = in_ch // 2 self.squeeze = nn.Sequential( nn.Conv2d(in_ch, s, kernel_size=1, bias=False), nn.BatchNorm2d(s), nn.LeakyReLU(0.1, inplace=True) ) self.expand1 = nn.Sequential( nn.Conv2d(s, e1, kernel_size=1, bias=False), nn.BatchNorm2d(e1), nn.LeakyReLU(0.1, inplace=True) ) self.expand3 = nn.Sequential( nn.Conv2d(s, e3, kernel_size=3, padding=1, bias=False), nn.BatchNorm2d(e3), nn.LeakyReLU(0.1, inplace=True) ) def forward(self, x): s = self.squeeze(x) e1 = self.expand1(s) e3 = self.expand3(s) out = torch.cat([e1, e3], dim=1) return out + x

In VGG-like architectures, FR blocks are stacked by replacing VGG conv groups and connecting via pooling layers, with shortcut connections joining outputs at major pooling boundaries (Qassim et al., 2017).

4. Functional Motivation and Parameter Efficiency

The FR module leverages channel reduction (squeeze) to minimize parameters while maintaining nonlinear representational capacity through dual expansion paths. The residual skip connection was explicitly shown to mitigate the accuracy loss typically incurred by aggressive channel bottlenecking. In empirical ablation (Oh et al., 2020), the addition of the residual connection to a Fire module increased mAP on KITTI from 86.31% to 90.25%, with size constant at 116.8 MB.

Parameter reduction is asymptotically proportional to $s/C$ for $s \ll C$ compared to a standard $3 \times 3$ convolution layer with $C$ channels. For instance, FRDet16 with $k=4$ ($s = C/16$) yielded a 50.8% model size reduction compared to YOLOv3, while achieving a 1.12% mAP gain (Oh et al., 2020). In the context of Residual-Squeeze-VGG16, FR modules reduced model size by 88.4% and cut training time by 23.9% compared to standard VGG16, at the cost of only a 2.3% drop in Top-1 accuracy (Qassim et al., 2017).

5. Empirical Performance and Ablation

Extensive quantitative results evidence FR modules’ effectiveness. Select metrics (all on KITTI or MIT Places365 unless specified):

Model/Variant	mAP (%)	Model Size (MB / GB)	Top-1 Acc. (%)	BFLOPS	FPS (NVIDIA Xavier)
FRDet16	91.26	118.5 MB	–	28.05	31.3
YOLOv3	90.15	240.7 MB	–	63.36	23.6
Fire-only (no res)	86.31	116.8 MB	–	–	–
FR: k=3	90.22	126.9 MB	–	–	–
ResSquVGG16	–	1.23 GB	51.68	–	–
VGG-16	–	10.6 GB	54.00	–	–

In all cases, the addition of residual skip connections maintained or improved accuracy compared to non-residual or purely bottlenecked structures, at materially reduced computational cost and model size (Oh et al., 2020, Qassim et al., 2017).

6. Comparison to Other Lightweight and Residual Architectures

Relative to standard Fire modules (as in SqueezeDet, Tinier-YOLO), the inclusion of residual connections increases mAP by approximately 4% (from 86% to 90% on KITTI) at constant parameter footprint (Oh et al., 2020). FR modules provide similar or superior mAP compared to plain residual blocks (e.g., as used in YOLOv3) with approximately half the parameter count and FLOPs. Compared to MobileNet-style blocks, FR modules utilize standard convolutions rather than depthwise separable convolutions, and were found to yield a better speed/accuracy tradeoff on embedded GPUs in the automotive domain (Oh et al., 2020).

7. Fire-Residual Module in Fire Spread Modeling

In the context of wildfire modeling, a Fire-Residual module (distinct from the neural architecture above) is an optimization-based framework for assimilating fire perimeters and satellite detections in fire spread models (Caus et al., 2018). Here, the residual is defined as the pointwise deviation from the eikonal equation governing fire arrival time and rate of spread, $||\nabla T(x,y)||_2 = 1/R(x, y, T, \nabla T)$, and is minimized (typically in $L^2$ norm) subject to perimeter and detection constraints. Multilevel descent algorithms, using projected search directions in the constraint nullspace, are employed to optimize the fire arrival time field $T(x,y)$ so that it is consistent with observed perimeters, terrain, fuel, and assimilation data. This enables the construction of physically consistent synthetic fire histories for coupled atmosphere–fire spinup, with empirical tests demonstrating up to two orders of magnitude reduction in residual over multigrid cycles (Caus et al., 2018).

---

In summary, the Fire-Residual module—whether as a neural network primitive for lightweight, accurate deep models or as a fire spread model assimilation framework—refers to the systematic use of residual-based architectural or numerical correction to optimize for both efficiency and fidelity as per the domain constraints (Oh et al., 2020, Caus et al., 2018, Qassim et al., 2017).