We propose an encoder-decoder segmentation network tailored for black ice detection in thermal images, named MsDCNet_p (Multi-scale Dilated Convolution Network with Parallel dilated convolution modules). It is important to note that the network operates exclusively on thermal infrared images; the 3-channel input arises solely from replicating the single-channel grayscale thermal image to maintain compatibility with standard deep learning frameworks. Since no RGB imagery is processed, the complex issue of IR-RGB synchronization does not apply to this system. The overall architecture is illustrated conceptually in Fig. 3. It consists of two main components: an encoder that extracts multi-scale features from the input image, and a decoder that reconstructs a segmentation mask via pixel-wise classification from those features.

The three encoder-stage resolutions (144 × 192, 72 × 96, and 36 × 48) were not arbitrarily chosen, rather, they are naturally derived from the network’s hierarchical down-sampling design concept. Starting from the 576 × 768 input image, two initial stride-2 convolutional layers reduce the spatial resolution to 1/4, yielding a 144 × 192 feature map. This initial compression step reduces the computational cost of subsequent operations without discarding essential spatial information. The three subsequent encoder blocks then progressively halve the resolution using stride-2 down-sampling (144 × 192→72 × 96→36 × 48). This hierarchical structure allows each encoder stage to specialize in features at a specific scale. Encoder Block-1 (144 × 192) captures fine-grained local texture details, which is important for detecting thin black ice boundaries, Encoder Block-2 (72 × 96) integrates intermediate contextual information, and Encoder Block-3 (36 × 48) encodes broad semantic context including the overall thermal distribution across the road surface.

Within the MsDC_p module, parallel processing consistency is structurally guaranteed because all parallel paths (DCx modules) share the exact same input tensor. Each path independently applies a dilated convolution with a distinct dilation rate to capture features at various spatial scales simultaneously. These output feature maps, which share the same spatial dimensions, are then concatenated along the channel dimension. A final 1 × 1 convolution normalizes the channel count to produce a single fully synchronized output tensor (as in Eqs. (5) and (6)). Therefore, data discrepancy between paths fundamentally cannot occur. Finally, to prevent the loss of high-frequency spatial details during the encoding process, skip connections link the corresponding encoder and decoder stages. The decoder then utilizes stride-2 transposed convolutions to progressively restore the segmentation map back to the full 576 × 768 resolution, as described in Section 3.2.3.

The decoder uses transposed convolutions (learnable up-sampling, also known as deconvolution) to progressively increase the resolution of the feature maps, combining them with features from the encoder via skip connections to refine the segmentation boundaries. All convolution layers in the network use a kernel size of 3 × 3 (except 1 × 1 conv used for channel adjustment in some places), followed by ReLU activation and batch normalization, which helps stabilize training. To reduce computation, the model begins with an initial down-sampling: the input image is first passed through two 3 × 3 conv layers with stride 2, which reduce the spatial resolution to 1/4 (i.e., 144 × 192) while increasing the feature channels.

After this initial compression, the encoder is organized into multiple encoder blocks (stages). In the proposed MsDCNet_p design, we used 3 encoder blocks (encoder block 1~3), each operating at successively lower resolutions. Each encoder block halves the spatial size (via strided convolution) and outputs a set of fused multi-scale features. Specifically, an encoder block takes as input a feature map of size (H, W, C_in) and produces an output of size (H/2, W/2, C_out), where H and W are halved.

Within each encoder block of the MsDCNet_p, we implement the multi-scale dilated convolutional (MsDC_p) module with p parallel dilated convolutional (DCx) modules where x denotes the dilation rate from 1 to p as illustrated in Figs. 4 and 5.

First, a 1 × 1 convolution may be applied to the input feature map to reduce the channel dimensionality by half. This step is done to cut down the computational cost when we concatenate multiple parallel feature maps; by shrinking the channel count up front, we ensure the concatenated output does not blow up in size even if many parallel paths are used.

In MsDC_p, p denotes the number of DCx modules within each encoder block, which is a parameter with values from 2 to 6. The dilation rate x ranges from 1 up to p. For example, MsDCNet_4 has 3 encoder blocks with each 4 parallel convolutional layers (DC1~DC4 module) in each encoder block, with dilation rates tailored accordingly. Each parallel path (DCx) within an encoder block has a ResNet-style two-layer structure. Concretely, in each encoder block, the first layer is a 3 × 3 convolution with stride-2 (to achieve the down-sampling of that block) and a dilation rate drx (if dilation is used here) or effectively a normal convolution if we consider dilation = 1 for the first layer. The second layer is a 3 × 3 dilated convolution with the same dilation rate drx. We include a skip connection that adds the appropriately down-sampled input of the block to the output of the second layer (this skip has a 1 × 1 convolution with stride-2 to match dimensions when necessary), forming a residual block.

In a MsDCN_p module, we set the dilation rates in the DCx parallel paths to a fixed set of values that span a range from 1 (no dilation) to p (for P parallel paths). For instance, if p=4, we might use dilation rates {1, 2, 3, 4} for the four parallel paths, i.e., DC1, DC2, DC3, and DC4. In our implementation MsDCNet_6 uses dilation rates {1, 2, 3, 4, 5, 6} in each encoder block.

The MsDC_p module is designed to capture multi-scale features by combining several parallel DCx modules, each with a distinct dilation rate, followed by concatenation and dimensionality restoration using a 1 × 1 convolution.

DCx Module: The DCx module forms the basic building block of our architecture, where x denotes the dilation rate. Each DCx module consists of sequential convolutional operations with residual connections. For an input tensor X∈RH×W×C the DCx module with dilation rate drx performs the following operations: (1)h1=C3×3(X),h2=h1+C3×3drx(h1),h3=C3×3(h2),h4=h3+C3×3drx(h3)DCx(X,drx)=h4where C3×3 represents a standard 3 × 3 convolution with n output channels, and C3×3drx denotes a 3 × 3 dilated convolution with dilation rate drx. The dilated convolution operation used in the DCx module, denoted as C3×3drx can be mathematically expressed as (2)Ck×kdrx(X)(i,j)=∑m=1k∑n=1kw(m,n)⋅X(i+drx⋅(m−⌈k2⌉),j+drx⋅(n−⌈k2⌉))where drx is the dilation rate, k is the kernel size (3 in our case), and w represents the weights of the convolutional kernel.

MsDC_p Module: For the complete MsDC_p architecture, where p represents the number of parallel DCx modules, the mathematical formulation is as follows. The input tensor X∈RH×W×m undergoes an initial dimensionality reduction using a 1 × 1 convolution operation, (3)Z=C1×1(X)where Z∈RH×W×n and n=m/2. This step reduces the number of channels to half, ensuring computational efficiency while maintaining spatial dimensions.

The reduced feature map Z is passed through P parallel DCx modules, each with a unique dilation rate drx. For the p-th DCx module, the output is defined as (4)Yp=DCp(Z,drp)where drp=p (i.e., the dilation rate increases incrementally for each parallel branch). Each DCx module captures features at a specific scale, and its output is represented as Yp∈RH×W×n. The outputs of all parallel DCx modules are concatenated along the channel dimension to form a unified multi-scale feature map, (5)Ycat=Y1∥Y2∥…∥YPwhere ∥ denotes channel-wise concatenation. The resulting tensor Ycat has dimensions RH×W×(P⋅n) effectively combining features from all scales. To restore the original number of channels in the output tensor, a final 1 × 1 convolution is applied to Ycat, (6)Yout=C1×1(Ycat),where Yout=RH×W×m matches the channel count of the input tensor X. This step ensures that the multi-scale features are integrated into a compact representation suitable for downstream tasks. The entire MsDC_p module can be expressed as (7)MsDC_p(X)=C1×1(∥x=1PDCx(C1×1(X),x))

The use of dilated convolutions in parallel branches allows for an expanded receptive field without increasing kernel size or computational complexity. For P parallel branches, the effective receptive field ranges from 3 × 3 (for dr1=1) to (2P+1)×(2P+1) (for drx=P), enabling efficient multi-scale context aggregation.

By combining these parallel convolutional layers, the encoder block can extract features responsive to patterns of different sizes: small dilation focuses on fine details and small objects, whereas larger dilation (e.g., 5 or 6) captures broader context from a larger receptive field. We concatenate the output feature maps from all parallel paths to form the encoder block’s output (which then may be projected by a 1 × 1 convolution to control C_out). Through this concatenation, neurons in the fused feature map effectively encode multi-scale semantic information; some neurons aggregate information from a wide area via the high-dilation path, others focus on local details via the low-dilation path.

This multi-scale feature fusion enriches the representation for complex tasks like black ice segmentation where both global context (e.g., overall road temperature trends) and local texture (e.g., smooth icy patch vs. rough asphalt) are relevant. After three encoder blocks of the MsDCNet_p, the feature map resolution is 1/32 of the input (i.e., 18 × 24 for 576 × 768 input). The decoder then performs the reverse process: it consists of a series of decoder blocks that progressively up-sample the feature maps back to the original resolution. Table 2 presents the dilation rate configurations for each MsDCNet_p variant, following the multi-scale dilated convolution framework of with uniform rates applied across all encoder blocks.

Our decoder design primarily focuses on feature refinement and up-sampling. Each decoder block takes a low-resolution feature map and produces a feature map at 2× higher spatial resolution. We use transposed convolutions with stride-2 (also known as decon-volutional layers) for up-sampling, because learnable transposed convolution can potentially recover spatial details more accurately by learning the up-sampling filters. However, naive transposed convolution can introduce checkerboard artifacts in the output if not carefully configured. To avoid this, we use a kernel size of 3 × 3 for transposed conv and follow best practices such as odd kernel overlaps as suggested by Odena et al. [31].

In each decoder block, similar to the encoder, we include some 1 × 1 convolutions to adjust channel dimensions. As depicted in Fig. 6, a decoder block with input channel count m and output channel count n will first apply a 1 × 1 convolution to reduce the channels from m to m/2, then apply a 3 × 3 transposed convolution (stride-2) to double the width and height, and finally a 3 × 3 convolution to increase the channels to n. We also concatenate (or add) the corresponding encoder block’s output via skip connection at the appropriate stage before the final convolution, to reintroduce fine-grained features. For example, the decoder block that up-samples from 1/16 to 1/8 resolution will take the 1/16 feature map (up-sampled to 1/8) and fuse it with the encoder’s 1/8 feature map (from Encoder Block 1) before outputting the 1/8 feature. This skip fusion helps recover edges of black ice regions that the encoder’s deeper layers might have blurred.

After the final decoder block, we obtain a feature map at 1/2 resolution (since we had one more decoder block than encoder block in MsDCNet_p for P parallel paths as explained below) which is then up-sampled one more time to full 576 × 768 resolution using a transposed conv or interpolation, and a final 1 × 1 convolution produces the two-channel output. We apply a softmax or sigmoid on these logits during training for the segmentation loss.

In the proposed AdaMsDCNet_p, we assign larger dilation rates to early encoder blocks (when feature maps are larger) and smaller dilation rates to later blocks (when feature maps are small). This is a main difference with the MsDCNet_p, which allocates the same dilation rates in every encoder block. This method of multi-scale dilation rate with depth-varying rates is as to maintain a roughly consistent effective receptive field in terms of original image pixels and to avoid the extreme sparsity at deeper layers. In practice, we define a maximum dilation for the first block equal to P (the number of parallel paths), and then reduce the maximum dilation in subsequent blocks.

For example, consider AdaMsDCNet_9 (our largest variant with 9 parallel paths). In encoder block-1 (input 144 × 192), we use 9 parallel convolution layers with dilation rates {1, 5, 9, 13, 17, 21, 25, 29, 33}, i.e., starting at 1 and incrementing by 4. This covers a wide range of receptive fields in the high-resolution feature map. In encoder block-2 (input 72 × 96), we also use 9 paths, but with dilation rates {1, 3, 5, 7, 9, 11, 13, 15, 17} (increment by 2). In encoder block-3 (36 × 48 input), we use dilation rates {1, 2, 3, 4, 5, 6, 7, 8, 9} (increment by 1). Thus, the spacing between dilation rates is narrowed at deeper levels (4→2→1). Effectively, the last encoder block-3 focuses more on fine details (since at 1/16 scale even dilation 9 corresponds to a moderate area in the original image), while the first encoder block-1 can focus on broad context (dilation up to 33 covering a large region of the input). This staged reduction of dilation ensures that we do not end up with a situation like MsDCNet_6’s encoder block-3 using dilation 6 on 1/32 features (which would skip too many pixels). Instead, AdaMsDCNet_9’s largest dilation at the deepest block is 9 on 1/16 features, which still samples reasonably densely.

This strategy is inspired by the concept of hybrid dilation but implemented in a parallel multi-branch manner. By maintaining appropriate receptive fields at each level, we capture multi-scale context without incurring the gridding artifact. In essence, AdaMsDCNet_p’s encoder blocks produce overlapping receptive fields across paths and across blocks, so that no portion of a black ice region goes unseen. Empirically, this led to better segmentation of small black ice patches that MsDCNet_p sometimes missed due to overly sparse sampling in deeper layers.

In the proposed AdaMsDCNet_p architecture, the DCx module used in MsDCNet_p (Fig. 4) should be modified as mDCx as following Fig. 7. The exemplary encoder block-1, 2, and 3 of the AdaMsDCNet_p is depicted in Fig. 8 and Table 3.

In the AdaMsDCNet_p, dilation rate drp of the p-th mDCx module in Eq. (4) varies adaptively according to the encoder block depth and each characterized by a unique dilation rate. This can be rewritten as (8)Yp=mDCp(Z,drp)where drp is not always equal to p but varies adaptively by encoder block depth. The adaptive dilation rates are generalized distinctly for each encoder block as follows. (9)Encoder Block−1:Ycat=Y1∥Y5∥Y9∥…∥Y(4p−3),with  drp incremented by 4,Encoder Block−2:Ycat=Y1∥Y5∥Y9∥…∥Y(2p−1), with  drp incremented by 2,Encoder Block−3:Ycat=Y1∥Y5∥Y9∥…∥Yp, with drp incremented by 1.

Also, the complete AdaMsDCNet_p module operation can be rewritten as (10)AdaMsDC_p(X)=C1×1(∥x=1PmDCx(C1×1(X),drp))

This adaptive multi-scale dilation scheme ensures efficient coverage of diverse receptive fields, capturing both detailed textures and broad contextual information, significantly improving the detection of small black ice regions while maintaining computational efficiency suitable for real-time applications.

To ensure real-time performance, AdaMsDCNet_p further reduces the number of feature channels throughout the network. In many CNNs, it is common to double the number of channels after each down-sampling (to preserve capacity as spatial size shrinks). MsDCNet_p partly followed this (going from 64 channels after encoder block-1 to 96 after encoder block-2 to 128 after encoder block-3 in our example). However, this growth, combined with multiple paths, resulted in a large parameter count for higher P. In AdaMsDCNet_p, we opted not to multiply channels by 2 at each stage. Instead, we increase channels more gradually: roughly adding a constant number of channels per block. For instance, in AdaMsDCNet_p we might use output of encoder block-1 has 64 channels, encoder block-2 has 80 channels, encoder block-3 has 96 channels. This linear growth contrasts with doubling, which would have been 64→128→256.

As a result, even though AdaMsDCNet_9 has more parallel convolution paths than MsDCNet_6, its total channel count at deeper layers is much lower. Moreover, within each encoder block, before applying the parallel convolution paths, we still perform the 1 × 1 channel reduction as in MsDCNet_p. Thus, each path operates on a smaller slice of channels. The skip connections between encoder and decoder also use fewer channels accordingly. All these adjustments dramatically cut down the parameter count. Table 4 quantifies this by comparing the parameter sizes of classical segmentation networks and the proposed model variants, confirming that the AdaMsDCNet series achieves an order-of-magnitude reduction relative to conventional architectures. MsDCNet_6 had 20.7M parameters, whereas AdaMsDCNet_9 with even more branches has only less than 1.86M. In other words, through our efficient design, AdaMsDCNet_9 is about 11 times smaller than MsDCNet_6, and even AdaMsDCNet_9 is 6 times smaller than LinkNet and an order of magnitude smaller than DeepLabv3+ or PSPNet. It is worth noting that such an aggressive reduction could have impacted accuracy; however, the multi-scale feature fusion appears to compensate effectively, as AdaMsDCNet_p models achieve comparable segmentation performance to MsDCNet_p models.

The decoder in AdaMsDCNet_p is the same structure as that of MsDCNet_p, with the same channel reduction and transposed convolution steps in each block as shown in Fig. 6. The channel sizes for each decoder block are adjusted to match the slimmer encoder. By the final decoder stage, we end up with 32 channels at 1/2 resolution, which are then converted to the output classes. We also ensure that skip connections from encoder to decoder are in place for each resolution (1/16, 1/8, 1/4, and even 1/2 if we consider the initial input as skip to final output convolution).

It is noted that the proposed AdaMsDCNet_p preserves the core multi-scale encoder-decoder design of MsDCNet_p but optimizes the dilation usage and network width to be both more effective and more efficient. Based on the desired accuracy trade-off, specific variant model of AdaMsDCNet_p can be chosen. In our experiments, AdaMsDCNet_6 to AdaMsDCNet_9 provided the best accuracy, with AdaMsDCNet_9 slightly better, while still being lightweight enough for real-time inference.

The experimental platform ran Ubuntu 18.04 LTS and equipped with four NVIDIA GeForce RTX 2080 Ti GPUs, each with 11 GB of memory. The deep learning implementation utilized Keras 3.12.1 and TensorFlow 2.20.2 frameworks with Python 3.12.1. Training was conducted with 100 epochs and variable batch sizes (1, 2, 4, 8, 16) to evaluate optimal performance conditions across different computational constraints.

Loss Function Selection: The training process employed the standard categorical cross-entropy (CCE) loss with Adam optimizer (β₁ = 0.9, β₂ = 0.999, ϵ = 10⁻⁸), utilizing an initial learning rate of 0.001 with exponential decay scheduling (decay rate = 0.96, decay steps = 1000) to accelerate convergence while preventing oscillations. The selection of the standard CCE loss as the training objective could be justified on two primary grounds. First, our controlled dataset of 1156 thermal images did not exhibit the severe class imbalance that typically requires alternative loss functions. Second, the main objective of this study was to demonstrate that the proposed architectural design, specially the adaptive multi-scale dilated convolutions with the 4→2→1 progression, is the principal driver of the observed segmentation performance. By using standard CCE as a baseline, we can demonstrate that the performance improvements are driven by our adaptive multi-scale dilated convolutions, rather than specialized optimization strategies.

We acknowledge, however, that this selection of the standard CCE may slightly limit the model’s sensitivity to extremely small and thin ice patches. Because CCE weights all pixels equally, the network may show reduced sensitivity to extremely small or thin black ice patches. This is particularly evident at formation boundaries where thermal contrast is faint, occasionally leading to false negatives at the patch edges. In real-world outdoor conditions, where black ice occupies a much smaller pixel proportion, class imbalance-aware alternatives like Focal Loss or Dice Loss could significantly improve detection sensitivity. Therefore, systematically comparing these loss functions is a crucial direction for our future work as discussed in Section 5.

For edge deployment validation, the trained models were converted to TensorFlow Lite format and deployed on the NVIDIA Jetson Nano Developer Kit (128-core Maxwell GPU, 4 GB LPDDR4 memory), representing a resource-constrained embedded platform typical of automotive and roadside monitoring applications. All inference benchmarks were conducted under maximum performance mode (10 W power budget) with GPU acceleration enabled.

The segmentation performance was assessed using a comprehensive set of evaluation metrics. The main metrics concerned are Mean Intersection over Union (mIoU) for overall segmentation quality and class-specific Black-Ice IoU for safety-critical detection accuracy. The Intersection over Union (IoU) quantifies the overlap between predicted segmentation results and ground truth annotations for individual classes. Black-Ice IoU specifically measures the segmentation accuracy for the critical black ice class alone, defined as(11)Black-Ice IoU=|PBI∩GBI||PBI∪GBI|where PBI represents the predicted black ice mask and GBI denotes the ground truth black ice mask. Note that an individual Black-Ice IoU specifically measures the segmentation accuracy for the critical black ice class only. The mIoU represents the averaged IoU values across all segmentation classes (background, road surface, and black ice regions), providing a comprehensive performance indicator. The mathematical formulation is defined in Eq. (12).(12)mIoU=1K+1∑i=1KX iiTi+∑j=1K(X ji−X ii)where K represents the number of classes, Ti denotes the total pixel count for class i, Xii represents the true positive pixels and Xji represents the false positive pixels from true class j misclassified as class i. This dual-metric approach ensures comprehensive evaluation: mIoU reflects general segmentation robustness across all diverse environmental conditions (general model robustness), while Black-Ice IoU specifically measures detection accuracy for safety-critical detection performance (class-specific performance assessment). In addition, in order to provide a more thorough evaluation of detection performance, particularly for small and irregular black ice patches, we additionally report Precision, Recall, and F1-Score for the black ice class as defined in Eq. (13)(13)Precision=TPTP+FP,Recall=TPTP+FN,F1−Score=2×Precision×RecallPrecision+Recallwhere TP, FP, and FN denote true positive, false positive, and false negative pixels for the black ice class, respectively. Precision measures the proportion of predicted black ice pixels that are correct (low false alarm rate), while Recall measures the proportion of actual black ice pixels that are detected (low miss rate). The F1-Score provides a harmonic mean balancing these two objectives, which is critical in safety applications where both false alarms and missed detections carry operational consequences.

AdaMsDCNet achieves real-time black ice area segmentation on the NVIDIA Jetson Nano platform, processing approximately 3.94~5.63 frames per second (FPS) at a 576 × 768 resolution, satisfying the operational demands for onboard roadway monitoring. Table 6 represents the comprehensive performance comparisons between the proposed AdaMsDCNet architectures and established semantic segmentation models on the thermal black ice dataset. The evaluation encompasses computational efficiency (FPS on Jetson Nano), model complexity (parameter count), and segmentation accuracy (mIoU and Black-Ice IoU), and three additional class-specific detection metrics—Precision, Recall, and F1-Score for the black ice class across two batch size configurations (8 and 16). These additional metrics provide a more thorough assessment of detection reliability, as both false alarms (low Precision) and missed detections (low Recall) carry safety consequences in road ice monitoring applications.

As shown in Table 6, inference vary significantly across models. U-Net (0.24 FPS), PSPNet (0.14 FPS), and DeepLabV3+ (0.19 FPS) all fail to meet real-time requirements on Jetson Nano, as their large model size and computational demands result in FPS values well below 1. On the other hand, ENet and LinkNet achieve FPS values of 1.95 and 3.72, respectively, which means they can perform real-time black ice area segmentation. The experimental results in Table 6 demonstrate the superior performance of the proposed AdaMsDCNet series over conventional semantic segmentation architectures across multiple evaluation criteria. The comprehensive evaluation encompasses both computational efficiency (FPS) and segmentation accuracy (mIoU and class-specific black ice IoU) on the NVIDIA Jetson Nano embedded platform.

Computational Efficiency Performance: The experimental results demonstrate substantial computational advantages of the AdaMsDCNet series over conventional architectures. Traditional deep segmentation models (U-Net, PSPNet, DeepLabv3+) exhibit severely limited real-time capabilities with FPS values below 0.25, rendering them impractical for time-critical hazard detection applications. The large parameter counts (31~134M) and memory requirements exceed the computational capacity of embedded platforms, necessitating cloud-based processing with associated latency penalties. In contrast, all AdaMsDCNet variants achieve remarkable real-time performance, with processing speeds ranging from 3.94 to 5.63 FPS, substantially outperforming traditional deep learning models. Notably, U-Net, PSPNet, and DeepLabV3+ demonstrate severely limited real-time capabilities with FPS values of 0.24, 0.14, and 0.19, respectively, rendering them unsuitable for practical deployment scenarios requiring immediate hazard detection. The progressive performance scaling across AdaMsDCNet variants (from AdaMsDCNet_2 to AdaMsDCNet_9) reveals an optimal trade-off between accuracy and computational efficiency. Even the most compact variant, AdaMsDCNet_2, achieves the highest processing speed of 5.63 FPS and surpasses LinkNet in mIoU (+0.56 pp), Black-Ice IoU (+0.55 pp), and F1-Score (+0.29 pp), while being 23.5 times smaller in parameter count. It demonstrates that the AdaMsDCNet design achieves superior accuracy with substantially lower computational overhead. Meanwhile, AdaMsDCNet_9 demonstrates peak accuracy performance with acceptable real-time processing at 3.94 FPS.

Segmentation Accuracy Performance: The mIoU evaluation establishes the superior accuracy of AdaMsDCNet architectures across all environmental conditions. AdaMsDCNet_9 achieves the highest overall performance with 96.47% mIoU (batch size 8), representing substantial improvements over baseline methods: +26.78 percentage points over U-Net, +10.63 over PSPNet, +2.832 over DeepLabv3+, and +1.09 over LinkNet. Critically, U-Net exhibits a Recall of only 67.94%, a gap of 29.88 pp below AdaMsDCNet_9, which indicates that approximately one-third of actual black ice pixels are missed. Such a miss rate is unacceptable in safety-critical road monitoring applications. Against DeepLabV3+, AdaMsDCNet_9 achieves +2.82 pp mIoU and +4.67 pp Recall improvement, and against LinkNet, +1.08 pp mIoU and +0.77 pp Recall improvement. This accuracy enhancement demonstrates that the proposed multi-scale feature fusion mechanism effectively compensates for the aggressive parameter reduction, capturing both fine-grained texture details and broad contextual information critical for distinguishing subtle black ice formations from wet pavement.

Batch Size Robustness: The mIoU variation between batch size 8 and 16 across the AdaMsDCNet series is limited to an average of 0.18 percentage points (maximum 0.21 pp for AdaMsDCNet_2), and the Black-Ice IoU variation averages 0.24 pp (maximum 0.31 pp). This minimal degradation under differing batch configurations demonstrates stable performance under varying computational conditions, providing indirect evidence of deployment robustness. We note that U-Net, PSPNet, and DeepLabV3+ could not be evaluated at batch size 16 due to GPU memory constraints on the Jetson Nano (4GB LPDDR4), further confirming the practical deployment advantages of the AdaMsDCNet series.

It should be acknowledged that the current evaluation was conducted on a dataset collected under controlled indoor freezing conditions. The effects of real-world environmental noise, including ambient thermal interference from passing vehicles, precipitation-induced surface temperature variations, and sensor thermal drift, on both inference speed and segmentation accuracy were not directly measured in this study. Thermal infrared imaging provides an inherent advantage over optical sensing by relying on emissivity-based temperature gradients rather than reflected light, thus maintaining robustness to illumination-induced noise. Nevertheless, a comprehensive evaluation under uncontrolled outdoor conditions remains an important direction for future work, as discussed in Section 5.

The class-specific Black-Ice IoU metric reveals exceptional detection capability for the safety-critical hazard class. AdaMsDCNet_9 attains 95.48% Black-Ice IoU, outperforming all comparison architectures including resource-intensive models. This represents a +34.1% point improvement over U-Net (61.38%) and +1.11 over the lightweight LinkNet baseline (94.37%). The consistent superiority across both mIoU and Black-Ice IoU metrics indicates that the adaptive dilation strategy effectively mitigates the checkerboard artifacts associated with naive dilated convolution implementations, preserving precise boundary delineation for irregular ice patches. Fig. 11a shows the Pareto frontier analysis, demonstrating that all AdaMsDCNet variants simultaneously outperform baseline architectures in both accuracy and inference speed. Notably, AdaMsDCNet_2 achieves 5.63 FPS, the fastest among all evaluated models, while maintaining 95.95% mIoU, surpassing LinkNet by 0.56 percentage points and 1.91 FPS. The model complexity analysis in Fig. 11b reveals that AdaMsDCNet_9 attains state-of-the-art accuracy (96.47% mIoU) with merely 1.86M parameters, representing an order-of-magnitude reduction compared to conventional architectures (31~134M parameters).

Scalability and Robustness Performance: The progressive performance scaling across AdaMsDCNet variants (subscripts 2–9 indicating parallel path counts) reveals optimal accuracy-efficiency trade-offs. Fig. 11a illustrates the Pareto frontier between segmentation accuracy and inference speed, demonstrating that mid-range configurations (AdaMsDCNet_5 to AdaMsDCNet_7) provide balanced performance for most deployment scenarios. AdaMsDCNet_2 offers the fastest processing (5.63 FPS) with competitive accuracy (95.95% mIoU), suitable for applications prioritizing latency minimization. Conversely, AdaMsDCNet_9 maximizes detection precision (96.47% mIoU, 95.48% Black-Ice IoU) while maintaining acceptable real-time performance (3.94 FPS), appropriate for safety-critical systems where false negatives carry severe consequences.

Batch size stability analysis reveals minimal performance degradation across computational configurations. The average mIoU variation between batch sizes 8 and 16 is only 0.18% points (σ = 0.21), and Black-Ice IoU varies by 0.24% points (σ = 0.31), indicating robust generalization independent of inference batch configurations. This stability enables flexible deployment adaptation to varying hardware constraints and power budgets in practical automotive environments. Fig. 12 presents the scalability characteristics of the AdaMsDCNet series, indicating that mid-range configurations (p = 5~7) provide optimal accuracy-efficiency trade-offs for most deployment scenarios.

Real-Time Deployment Demonstration: The deployment validation confirms that AdaMsDCNet operates continuously for extended monitoring periods (>8 h) without memory leaks or performance degradation, consuming approximately 7.2 W average power (within the 10 W thermal design power of Jetson Nano) [33]. The system achieves end-to-end latency of approximately 320 ms (including image acquisition, preprocessing, inference, and alert generation), satisfying the temporal requirements for proactive driver warnings at highway speeds (<1-s response time for vehicles traveling at 100 km/h provides >27 m reaction distance).