Estimation of Fractal Dimension and Semantic Segmentation of Motion-Blurred Images by Knowledge Distillation in Autonomous Vehicle

Abstract

Research on semantic segmentation for remote sensing road scenes advanced significantly, driven by autonomous driving technology. However, motion blur from camera or subject movements hampers segmentation performance. To address this issue, we propose a knowledge distillation-based semantic segmentation network (KDS-Net) that is robust to motion blur, eliminating the need for image restoration networks. KDS-Net leverages innovative knowledge distillation techniques and edge-enhanced segmentation loss to refine edge regions and improve segmentation precision across various receptive fields. To enhance the interpretability of segmentation quality under motion blur, we incorporate fractal dimension estimation to quantify the geometric complexity of class-specific regions, allowing for a structural assessment of predictions generated by the proposed knowledge distillation framework for autonomous driving. Experiments on well-known motion-blurred remote sensing road scene datasets (CamVid and KITTI) demonstrate mean IoU scores of 72.42% and 59.29%, respectively, surpassing state-of-the-art methods. Additionally, the lightweight KDS-Net (21.44 M parameters) enables real-time edge computing, mitigating data privacy concerns and communication overheads in internet of vehicles scenarios.

1. Introduction

The emergence of deep learning technology significantly expedited the progress of autonomous driving, thereby catalyzing research on semantic segmentation using road scene data and leading to remarkable advancements [1,2]. However, in most of these studies, clear images devoid of motion blur have been relied upon and the challenges posed by a motion-blurred environment neglected. In general, high-level knowledge needs to be extracted by combining low-level features such as points and lines when analyzing images. Motion-blurred images resulting from camera or subject movements often feature indistinct points and lines, which hinder the extraction of high-level information and diminish semantic segmentation accuracy. Consequently, segmentation techniques that performed well in the past also suffer a decline in performance in motion-blurred environments. This tendency implies a risk of dangerous accidents during autonomous driving when objects within images are not accurately recognized.

Various approaches have been explored to mitigate the decline in semantic segmentation accuracy in motion-blurred environments [3,4,5,6,7,8,9,10]. These approaches can be categorized into those that involve improving segmentation performance by first restoring motion-blurred images and those that do not include the restoration step before semantic segmentation is performed on images acquired from a front-viewing vehicle camera. The methods used to perform semantic segmentation after image restoration result in high segmentation accuracy, but the additional image restoration process inevitably increases the number of trainable parameters of the entire network and requires a very high inference time.

To address these drawbacks, this study presents a method for improving semantic segmentation performance in motion-blurred remote sensing images obtained from a vehicle’s front-viewing camera without using a blur restoration network. In contrast to prior research, this study presents four distinct contributions:

• The knowledge distillation (KD) technique is adopted to improve semantic segmentation performance at a low computational cost, without the additional restoration step for motion-blurred images captured from a vehicle’s front-viewing camera. For this purpose, a KD-based semantic segmentation network (KDS-Net) is proposed.
• A new type of edge-enhanced segmentation loss (EESL) is proposed to utilize edge features that disappear because of motion blur. To achieve this, an edge-mask generator (EMG) is designed to generate an edge mask from ground truth segmentation data, ensuring the KDS-Net’s robustness in edge regions.
• To enhance segmentation performance on objects of various sizes in a motion-blurred environment, multiscale inputs are used for the backbone encoder and decoder architecture, and the shallow convolution module (SCM) is applied to reduce the resultant increase in computational load. Additionally, a feature attention fusion module (FAFM) is proposed to utilize multiscale features.
• Our light KDS-Net minimizes the number of parameters to 21.44 million, demonstrating its ability to operate on embedded systems such as edge computing at real-time speed for real-world vehicle applications. From them, we confirm that KDS-Net can be applied to the edge intelligence-empowered internet of vehicles by removing data privacy concerns and communication overheads caused by transmitting the huge amount of images from a vehicle’s frontal-viewing camera to and receiving the segmentation result from the high computing cloud by 5G technology.
• To analyze the shape level consistency of the segmentation results under motion blur, we incorporate fractal dimension estimation to evaluate the complexity and irregularity of class-specific regions, thereby providing a structural measure of segmentation correctness within the proposed KD framework. In addition, the proposed model and code, along with experimental databases, are disclosed via GitHub (https://github.com/JSI5668/KDS-Net.git (accessed on 13 July 2025)) to facilitate fair evaluation by other researchers.

The remainder of this paper is organized as follows: Section 2 presents different semantic segmentation methods that involve using images obtained from a vehicle’s front-viewing camera; Section 3 details the proposed method; Section 4 presents an analysis of the experimental results; Section 5 provides relevant discussions; and Section 6 concludes the paper.

2. Related Work

Semantic segmentation methods that involve using images acquired from front-viewing cameras of vehicles are categorized into those that consider motion blur and those that do not. The methods in which motion blur is not considered are further classified into those that perform real-time semantic segmentation and those that achieve high accuracy without performing in real time. Semantic segmentation methods in which motion blur is considered are categorized based on whether they utilize a restoration network.

2.1. Not Considering Motion Blur

2.1.1. Semantic Segmentation for Real-Time Processing

Zhao et al. [11] emphasized the importance of not compromising image quality while increasing the speed of the semantic segmentation algorithm for practical tasks. They employed a method for lowering the resolution of input images to reduce computational load. A multi-branch approach was implemented to mitigate the decrease in segmentation accuracy. Detailed information loss occurs when the resolution of an input image is reduced. Zhao et al. applied a shallow convolutional neural network (CNN) for a bottom branch that uses original resolution images and a deep CNN for a top branch that uses 1/4 resolution images. Detailed information missed in the top branch owing to the low resolution was restored in the bottom branch, thus lowering the overall computational cost while maintaining accuracy. Li et al. [12] discovered that previous methods involving real-time processing utilized either dilated convolution, which maintains the number of parameters while generating a large receptive field, or depth-wise separable convolution, which can reduce the number of parameters. However, they suggested that simply replacing the standard convolution with depth-wise convolution is not advisable owing to significant performance degradation. They proposed a well-designed combination of dilated convolution and depth-wise separable convolution for real-time semantic segmentation.

Wu et al. [13] argued that spatial dependency and contextual information play a crucial role in enhancing segmentation accuracy. They designed a context-guided block (CG block) that maximizes the utilization of local features, surrounding context, and global context. They created a context-guided network (CGNet) based on CG blocks to reduce the number of parameters and efficiently use the memory space. These aforementioned techniques have high processing speed but limited semantic segmentation accuracy, leading to the exploration of the following methods.

2.1.2. Semantic Segmentation with High Accuracy

Chen et al. [14] proposed four enhanced versions, from DeeplabV1 to DeeplabV3-Plus, to improve the accuracy of semantic segmentation. They recommended actively using atrous convolution in DeeplabV1, atrous spatial pyramid pooling to capture multi-scale context in DeeplabV2, and atrous convolution in the existent residual network (ResNet) in DeeplabV3 to achieve a dense feature map. Finally, in DeeplabV3-Plus, semantic segmentation performance was enhanced by combining separable convolution with atrous convolution. Fu et al. [15] aimed to obtain rich contextual dependency in scene segmentation tasks using a self-attention mechanism. Unlike previous methods in which context information is acquired through multi-scale feature fusion, a dual-attention network (DANet) that adaptively integrates local features with global dependencies was used. For this purpose, two attention modules (position and channel attention modules) were added to the DANet. In the position attention module, the features of each position are selectively aggregated by using the weighted sum of the features of all positions. In the channel attention module, mutually dependent channel maps are selectively highlighted by integrating related features between all channel maps. The outputs of these two attention modules are then summed to improve feature representation, resulting in accurate semantic segmentation.

Wang et al. [16] emphasized that high-resolution representation is essential for semantic segmentation and proposed a high-resolution network (HRNet). Most previous methods involve restoring high-resolution representation from low-resolution representation. However, the HRNet is designed to maintain high-resolution representation throughout the process. Initially, the high-resolution subnetwork is used as the first stage. High-to-low resolution subnetworks are sequentially added, and each multi-resolution subnetwork is connected in parallel. This approach leads to rich semantic information and demonstrates excellence in various applications, including human pose estimation, semantic segmentation, and object detection. In the aforementioned methods, motion blur was not considered, resulting in degraded segmentation performance in motion-blurred images. Thus, methods in which motion blur is considered were explored.

2.2. Considering Motion Blur

Motion blur, which occurs when a camera shakes or a subject moves, degrades semantic segmentation performance owing to the resultant ambiguous edges and loss of texture information in images. To overcome this drawback, several studies have been conducted on semantic segmentation considering motion blur in images obtained from a vehicle’s front-viewing camera. These studies can be categorized into those in which image restoration was performed before segmentation and those in which image restoration was not included.

2.2.1. Semantic Segmentation with Motion Blur Restoration

Jeong et al. [3] initially performed image restoration to enhance semantic segmentation performance in motion-blurred images captured by a vehicle’s front-viewing camera and subsequently proposed a supervised dual-attention network for motion deblurring (SDAN-MD). The SDAN-MD is a multi-stage model that incorporates the UNet as a subnetwork. Spatial and channel attentions are used in each stage, with a supervised dual-attention module designed to provide a supervisory signal from the ground truth. Additionally, Jeong et al. utilized a feature map extracted from a pretrained segmentation network using a clear blur-free image as a perceptual loss to further improve semantic segmentation performance. Effectively restoring motion blur prior to semantic segmentation led to notable performance improvements. However, these methods involve extended processing times due to the additional blur restoration process. Thus, methods that do not involve blur restoration have also been explored.

2.2.2. Semantic Segmentation Without Motion Blur Restoration

Data Augmentation-Based Method

Kamann et al. [5] asserted that CNNs need to be robust to degraded images with noise and blur to ensure the safety of critical applications such as autonomous driving. They addressed this issue by enhancing bias towards object shapes. They used fake images where colors randomly chosen for each class label were alpha-blended into RGB training images and introduced a novel data augmentation technique known as painting by numbers. Consequently, their proposed network demonstrated superior performance over other networks in road scene databases. Franchi et al. [4] introduced a data augmentation technique that generates new unlabeled images from superpixels to enhance robustness, a fundamental requirement in semantic segmentation. They established components of an optimal deep CNN (DCNN) learning system for semantic segmentation by combining the system’s mixing technology with a teacher–student framework. Despite the minor performance improvements of these methods, further explorations have been undertaken to identify alternative approaches.

KD-Based Method

Guo et al. [6] observed that semantic segmentation performance is degraded because of the discrepancy between the feature distribution trained using clear images without blur and that using degraded images. They introduced a novel network leveraging teacher–student networks to bridge this discrepancy. The source network has the same target network architecture, where only the target network is used during testing.

Fan et al. [17] proposed augmentation-free dense contrastive knowledge distillation (Af-DCD) which transfers structural knowledge via masked feature mimicking and contrastive learning. This approach showed strong performance on frontal-view driving datasets such as CamVid and Cityscapes. Mansourian et al. [18] introduced attention-guided feature distillation (AttnFD), which uses attention priors to guide the student toward spatially informative regions of the teacher’s feature map. This spatial guidance improves boundary localization and overall segmentation accuracy. Liu et al. [19] proposed boundary-privileged knowledge distillation (BPKD), which separates edge and body regions, and applies region-specific distillation to enhance semantic consistency and structural awareness in the student model.

However, these methods, which utilize both teacher and student networks, present challenges owing to their high learning difficulty and potential performance discrepancies between the two networks. Thus, alternative methods have been proposed.

Enhanced Segmentation Model-Based Method

Vertens et al. [7] proposed a new CNN architecture that predicts the label and motion status of each pixel in images. They devised an architecture to learn the process of generating semantic motion labels by integrating optical flow maps and segmentation kernels through a pair of consecutive images. Yu et al. [8] introduced a technique in which segmentation and edge detection are synergistically combined for mutual benefit. They claimed that segmentation can be easily converted to contour edges for edge learning. Thus, they proposed a multi-task learning method for combined edge and segmentation learning and experimentally proved that their method can result in performance improvement in corrupted images having blur.

Zhang et al. [9] provided the DADA-seg database containing various elements such as motion blur and object occlusions. Furthermore, they proposed a multi-model segmentation architecture based on event-aware fusion (EF) and event-aware domain adaptation (EDA). Rahman et al. [10] claimed that segmentation models exhibiting strong performance remain vulnerable to diverse external factors, leading to diminished segmentation accuracy. To address this shortcoming, they proposed a failure detection framework for finding pixel-level errors. They designed the framework to learn a failure detection network while utilizing the features of the segmentation model. Accordingly, they devised a segmentation network robust to various conditions and experimentally proved its exceptional performance. However, given the escalating complexity of these methods, this study presents the following approach as a resolution.

Fusion of KD-Based and Enhanced Segmentation Model-Based Method

To address the drawbacks of the aforementioned methods, this study proposes the KDS-Net, a semantic segmentation network robust to motion blur. The KDS-Net eliminates the need for image restoration during inference by leveraging the advantages of the KD method and an enhanced segmentation model-based approach.

3. Proposed Method

3.1. Overview of Proposed Method

Figure 1 shows the overall procedure of our proposed method. In the training step (step (1)), motion-blurred images obtained from a vehicle’s front-viewing camera are captured. In step (2), these motion-blurred images are restored to clean images by applying a restoration network. The open and pretrained SDAN-MD model [3] was utilized as a restoration framework because it outperforms other restoration models in terms of semantic segmentation performance when applied to motion-blurred images. In step (3), the proposed KDS-Net is trained for semantic segmentation on both the restored images from step (2) and the motion-blurred images not restored in step (1).

Once step (3) is completed, the model trained for segmentation of both restored and unrestored images is employed as a teacher model to implement knowledge distillation (KD) onto a student model. In step (4), a student model is trained for testing, where the input is a motion-blurred image that has not undergone restoration. Here, the student model incorporates KD from the teacher model, which has been trained on a larger database and is trained to mimic the representations of the teacher model. Both our teacher and student models utilize the KDS-Net proposed in this study.

In the subsequent testing step, after a motion-blurred image is captured in step (5), semantic segmentation is directly performed using the student network of the KDS-Net without restoring the motion-blurred images. In other words, a restoration model is not required during testing because only the student model of the trained KDS-Net is used. The proposed KD method is explained in further detail in the following subsection.

3.2. KDS-Net for the Retoration of Motion-Blurred Image

In general, employing a vast database and network facilitates feature extraction, thereby enhancing the performance of deep learning technology. However, limitations in terms of capacity and processing speeds exist. KD is used to address these challenges by alleviating constraints such as memory space, learning time, and practical limitations, enabling improved performance across various tasks dependent on factors such as model complexity and database size [20]. The core idea of KD involves training a high-performance teacher model on a large database and transferring its knowledge to a student model for inference, allowing the student model to achieve comparable performance with a smaller database and simpler architecture.

This study proposes the KDS-Net, which enhances semantic segmentation performance in motion-blurred images without requiring image restoration during inference by utilizing KD. A large database was constructed by combining motion-deblurred images obtained using a pretrained restoration network with motion-blurred images. A segmentation network trained on this database served as the teacher model, while a network trained only on motion-blurred images was designated as the student model. The teacher and student models were designed with identical architectures to ensure compatibility and efficient knowledge transfer, with the teacher model leveraging the additional restored images to extract richer features during training.

The knowledge transferred through KD encompassed responses, features, and relations, and was passed to the student model via offline-KD, online-KD, or self-KD methods [21]. Offline-KD, where the student model is trained using a pretrained teacher model, was employed in this study. Features from the encoders of both models were extracted, and the mean squared error (MSE) between them was incorporated into the loss function. Instead of directly using the features, vector quantization was applied to map feature vectors in a codebook, enabling efficient knowledge transfer. This approach retained essential data features while helping the student model learn complex representations from the teacher model. Once trained, only the student model is utilized for inference.

3.2.1. Detail Description of KDS-Net

Figure 2 displays the overall architecture of the KDS-Net, which was used as both the teacher and student models in this study.

Table 1. Description of the KDS-Net encoder. The modules marked with an asterisk (*) in Stages 3 and 4 utilize identical filter sizes (excluding the number of input channels) and stride as Stage 2, with only the number of filters doubled. DB refers to the dense block illustrated in Figure 2.

Stage	Layer	Filter (Number of Filters, Size)	Stride	Padding	Output
1	Input	-	-	-	224 $\times$ 224 $\times$ 3
	DB (X0,0)	64, 7 $\times$ 7 $\times$ 3	2	3 $\times$ 3	112 $\times$ 112 $\times$ 64
	DB (X1,0)	64, 1 $\times$ 1 $\times$ 64 64, 3 $\times$ 3 $\times$ 64 256, 1 $\times$ 1 $\times$ 64	2	1 $\times$ 1	56 $\times$ 56 $\times$ 256
2	SCM	32, 3 $\times$ 3 $\times$ 3 64, 1 $\times$ 1 $\times$ 32 64, 3 $\times$ 3 $\times$ 64 125, 1 $\times$ 1 $\times$ 64 128, 1 $\times$ 1 $\times$ 128 256, 3 $\times$ 3 $\times$ 128 256, 3 $\times$ 3 $\times$ 256	1	1 $\times$ 1	56 $\times$ 56 $\times$ 256
	FAFM	256, 1 $\times$ 1 $\times$ 512 16, 1 $\times$ 1 $\times$ 16 256, 1 $\times$ 1 $\times$ 256	1	1 $\times$ 1	56 $\times$ 56 $\times$ 256
	DB (X2,0)	128, 1 $\times$ 1 $\times$ 512 128, 3 $\times$ 3 $\times$ 128 512, 1 $\times$ 1 $\times$ 128 128, 1 $\times$ 1 $\times$ 512 128, 3 $\times$ 3 $\times$ 128	1	1 $\times$ 1	28 $\times$ 28 $\times$ 512
3	SCM *	-	-	1 $\times$ 1	28 $\times$ 28 $\times$ 512
	FAFM *	-	-	-	28 $\times$ 28 $\times$ 512
	DB (X3,0)	-	-	1 $\times$ 1	14 $\times$ 14 $\times$ 1024
4	SCM *	-	-	1 $\times$ 1	14 $\times$ 14 $\times$ 1024
	FAFM *	-	-	-	14 $\times$ 14 $\times$ 1024
	DB (X4,0)	-	-	1 $\times$ 1	7 $\times$ 7 $\times$ 2048

and

Table 2. Description of the proposed KDS-Net decoder (Filters with stride and padding below all indicate the filters used in DB). DB refers to the dense block illustrated in Figure 2.

Layer	Filter (Number of Filters, Size)	Output
Upsample (X1,0)	-	112 $\times$ 112 $\times$ 256
Concatenate (X0,0, X1,0)	-	112 $\times$ 112 $\times$ 320
DB (X0,1)	64, 3 $\times$ 3 $\times$ 320 64, 3 $\times$ 3 $\times$ 64	112 $\times$ 112 $\times$ 64
Upsample (X2,0)	-	56 $\times$ 56 $\times$ 512
Concatenate (X1,0, X2,0)	-	56 $\times$ 56 $\times$ 768
DB (X1,1)	256, 3 $\times$ 3 $\times$ 768 256, 3 $\times$ 3 $\times$ 256	56 $\times$ 56 $\times$ 256
Upsample (X3,0)	-	28 $\times$ 28 $\times$ 1024
Concatenate (X2,0, X3,0)	-	28 $\times$ 28 $\times$ 1536
DB (X2,1)	512, 3 $\times$ 3 $\times$ 1536 512, 3 $\times$ 3 $\times$ 512	28 $\times$ 28 $\times$ 512
Upsample (X4,0)	-	14 $\times$ 14 $\times$ 2048
Concatenate (X3,0, X4,0)	-	14 $\times$ 14 $\times$ 3072
DB (X3,1)	256, 3 $\times$ 3 $\times$ 3072 256, 3 $\times$ 3 $\times$ 256	14 $\times$ 14 $\times$ 256
Upsample (X1,1)	-	112 $\times$ 112 $\times$ 256
Concatenate (X0,0, X0,1, X1,1)	-	112 $\times$ 112 $\times$ 384
DB (X0,2)	64, 3 $\times$ 3 $\times$ 384 64, 3 $\times$ 3 $\times$ 64	112 $\times$ 112 $\times$ 64
Upsample (X2,1)	-	56 $\times$ 56 $\times$ 512
Concatenate (X1,0, X1,1, X2,1)	-	56 $\times$ 56 $\times$ 1024
DB (X1,2)	256, 3 $\times$ 3 $\times$ 1024 256, 3 $\times$ 3 $\times$ 256	56 $\times$ 56 $\times$ 256
Upsample (X3,1)	-	28 $\times$ 28 $\times$ 256
Concatenate (X2,0, X2,1, X3,1)	-	28 $\times$ 28 $\times$ 1280
DB (X2,2)	128, 3 $\times$ 3 $\times$ 1280 128, 3 $\times$ 3 $\times$ 128	28 $\times$ 28 $\times$ 128
Upsample (X1,2)	-	112 $\times$ 112 $\times$ 256
Concatenate (X0,0, X0,1, X0,2, X1,2)	-	112 $\times$ 112 $\times$ 448
DB (X0,3)	64, 3 $\times$ 3 $\times$ 448 64, 3 $\times$ 3 $\times$ 64	112 $\times$ 112 $\times$ 64
Upsample (X2,2)	-	56 $\times$ 56 $\times$ 128
Concatenate (X1,0, X1,1, X1,2, X2,2)	-	56 $\times$ 56 $\times$ 896
DB (X1,3)	64, 3 $\times$ 3 $\times$ 896 64, 3 $\times$ 3 $\times$ 64	56 $\times$ 56 $\times$ 64
Upsample (X1,3)	-	112 $\times$ 112 $\times$ 64
Concatenate (X0,0, X0,1, X0,2, X0,3, X1,3)	-	56 $\times$ 56 $\times$ 896
DB (X0,4)	32, 3 $\times$ 3 $\times$ 320 32, 3 $\times$ 3 $\times$ 32	112 $\times$ 112 $\times$ 32
DB (X0,5)	16, 3 $\times$ 3 $\times$ 32 16, 3 $\times$ 3 $\times$ 16 12, 3 $\times$ 3 $\times$ 16	224 $\times$ 224 $\times$ 12

present the detailed architecture of the encoder and decoder of the KDS-Net. In the proposed KDS-Net, four different scaled images are used as the input, with each image represented at magnification ratios of ×1, ×1/2, ×1/4, and ×1/8, as shown in stages 1–4 in Figure 2. Once the original resolution image passes through the first encoder block, an image that has been downsampled to a ×1/2 magnification ratio becomes an input that passes through the SCM. The top image in Figure 3 illustrates the detailed architecture of the SCM. In SCM, two sets of 3 × 3 and 1 × 1 convolutional layers are used for efficiency and concatenated with the input of SCM. Then, the concatenated features are refined through the 1 × 1 layer and passed through the 3 × 3 layer.

After being passed through the FAFM, it is merged with a feature that has undergone processing in the first encoder block. The bottom image in Figure 3 depicts the detailed architecture of the FAFM. We fused the features in the FAFM by using channel attention. Channel attention was employed because as the encoder layers deepen, the spatial resolution of a feature map decreases, leading to information accumulation along the channel axis. In this case, we used a combination of global average pooling (GAP) and global max pooling (GMP) because these two pooling methods provide complementary information.

GAP calculates the average value of each channel, offering global contextual information that helps us understand the overall distribution of features. Conversely, GMP calculates the maximum value of each channel, highlighting the most important features and aiding in the identification of crucial information in specific regions. By combining these two pooling methods, we maximize the effectiveness of channel attention, thereby enabling more effective learning of inter-channel interactions and their relative importance. The mathematical formulations for the channel attention and FAFM we employed are as follows:

$$Z=Conv\left(X\right)$$

(1)

$$f_c^{GAP}=Conv\left({\displaystyle \genfrac{}{}{0pt}{}{1}{H\times W}}\sum _{i=1}^H\sum _{j=1}^W{Z}_{ijc}\right)$$

(2)

$$f_c^{GMP}=Conv(\max \left(Z_{ijc} \right|1\le i\le H, 1\le j\le W))$$

(3)

$$S_c=\sigma (f_c^{GAP}+f_c^{GMP})$$

(4)

$$X_{ijc}^{\prime }=X_{ijc}+(S_c·X_{ijc}).$$

(5)

The input $X$ is the concatenation of the output from the SCM and the output from the dense block of the previous stage, which is then transformed into $Z$ through a convolutional layer as shown in Equation (1). Subsequently, as shown in Equations (2)–(4), the channel information is summarized using GAP and GMP, and the importance of each channel $S_c$ is generated through the sigmoid function $\sigma$. Finally, this importance is reflected to produce the output $X_{ijc}^{\prime }$, as shown in Equation (5), which is the output of the FAFM with channel attention.

Through the FAFM in each encoder block, we facilitated the fusion of features from the image with a magnification ratio of ×1/2. This process was repeated until the feature of the image having a ×1/8 magnification ratio was fused and subsequently fed into the decoder. The decoder architecture of the KDS-Net is identical to that of the Nested U-Net [22], with the segmentation output of the final decoder block used to calculate the losses. In the KDS-Net, EESL, which incorporates the proposed EMG, is used alongside the categorical cross-entropy loss typically used in semantic segmentation. Detailed explanations of the EMG and EESL are provided in Section 3.2.2 and Section 3.3.2, respectively.

3.2.2. EMG

Recently, perceptual loss [23] has been widely employed along with per-pixel loss in image generation tasks such as style transfer or image synthesis. In this method, fake and real image pixels are not directly compared; instead, perceptual similarity is examined by performing comparisons in a feature space. A visual geometry group (VGG) network [24] pretrained with ImageNet is used. This approach aids in identifying high-level features, thereby facilitating the recognition of more intricate details. However, applying this method to semantic segmentation tasks has limitations. As image generation models such as generative adversarial networks (GANs) [25] typically produce three-channel outputs, a generated fake image is input into the VGG network, along with a real image, to extract a feature map. However, in semantic segmentation tasks, the number of output channels differs from the number of input channels, and the image pixel distributions vary significantly. Given these circumstances, this study introduces the EMG, which leverages the benefits of perceptual loss in semantic segmentation and alleviates the challenge of accurately detecting edges in the presence of motion blur.

We designed the EMG, a shallow CNN that generates an edge mask from the ground truth of semantic segmentation. The EMG was designed with four convolution layers as shown in Figure 4, with batch normalization and the rectified linear unit (ReLU) included between each layer. An edge mask, which is the EMG label, is required for training the EMG. Before the EMG is trained, the Laplacian filter is utilized to generate the ground truth edge mask, E*, from the ground truth segmentation mask, S*; this mask is then used as the label for training the EMG. In the first stage, the training label for the EMG is created. The model is frozen after completing the training for the EMG, which generates the predicted edge mask, Ê*, from S*. During EMG training, the utilized loss is cross-entropy loss, specifically termed as “edge loss” to distinguish it from the cross-entropy loss employed in the second stage. Subsequently, this model is utilized as a VGG network, with which we commonly use perceptual loss.

In the second stage, the segmentation network’s outputs, Ŝ and S*, are input into the EMG, and feature maps are extracted from each layer, where the difference between the two is reflected as L2 loss. This approach is used to reduce the difference between the edge of Ŝ and the edge of S*, resulting in more refined segmentation outputs. This can be expressed mathematically in Equations (6)–(9), and the detailed structure of the EMG is presented in

Table 3. Description of the proposed EMG.

Layer	Filter (Number of Filter, Size, Stride)	Padding	Input Size	Output Size
Input layer	-	-	224 × 224 × 1	224 × 224 × 1
1st Conv layer	16, 3 × 3 × 1, 1	1 × 1	224 × 224 × 1	224 × 224 × 16
2nd Conv layer	32, 3 × 3 × 16, 1	1 × 1	224 × 224 × 16	224 × 224 × 32
3rd Conv layer	64, 3 × 3 × 32, 1	1 × 1	224 × 224 × 32	224 × 224 × 64
4th Conv layer	2, 1 × 1 × 64, 1	1 × 1	224 × 224 × 64	224 × 224 × 2

.

E* = Laplacian (S*)

(6)

Ê* = EMG (S*)

(7)

Ê = EMG (Ŝ)

(8)

Edge loss = Cross entropy (Ê*, E*)

(9)

3.3. Loss Functions of KDS-Net

The KDS-Net proposed in this study utilizes cross-entropy loss, commonly employed in semantic segmentation, in addition to distillation loss, which transfers knowledge from a teacher model to a student model, and EESL. This EESL, designed to minimize edge discrepancies between the ground truth and model output, utilizes the EMG method introduced here. Further explanations for the two additional losses are provided in the following subsection.

3.3.1. Distillation Loss with Vector Quantization

In this study, the MSE was computed and applied as the distillation loss, ensuring that the features extracted from the student model closely resemble those extracted from the teacher model. The distillation equation used in this study is as follows:

$$L_{distillation}=\mathrm{ }\sum _{i=1}^4{\left({VQ(\varphi }_{ti}\right(I_B\left)\right)-VQ\left({\varphi }_{si}\right(I_B\left)\right)}^2$$

(10)

where I_B is the motion-blurred image used as an input. ${\varphi }_{ti}$ (I_B) represents the feature map of the teacher model extracted from the dense block in the i-th stage presented in Table 1, whereas ${\varphi }_{si}$ (I_B) represents the feature map of the student model extracted from the dense block in the i-th stage. Moreover, $VQ$ represents vector quantization (VQ). We adopted VQ as the basis for our knowledge distillation framework, as it offers an effective balance between compactness and representational fidelity. Unlike other compression techniques such as pruning or low-rank decomposition, which primarily reduce redundancy in parameter space, VQ discretizes feature space representations, enabling the student network to capture high-level semantics in a compressed yet structured form. This quantized guidance helps align the latent space of the student with that of the teacher without introducing additional architectural complexity. Furthermore, the codebook-based representation in VQ acts as an undetermined regularizer, encouraging stable and interpretable feature transfer during distillation. When VQ is used, v number of codewords are aggregated to form one codebook, resulting in a total of g codebooks. The value of continuous features is allocated to the nearest discrete codeword. In the experiment conducted with the training data, showing the best segmentation accuracy, we adjusted optimal parameter v to match the number of dimensions of a feature map extracted from each encoder block. We set g to 8000 and the number of encoder blocks for feature extraction to 3. Features were ultimately extracted from the second encoder block. Finally, this loss was trained to minimize the difference between features extracted from the teacher model and those extracted from the student model.

3.3.2. EESL with EMG

Motion-blurred images generally reduce segmentation accuracy because the edges in the semantic segmentation results are compromised owing to the loss of detailed information. Therefore, this study introduces the EMG, which aims to preserve edge information in the damaged semantic segmentation output as much as possible, as detailed in Section 3.2.2. The equation for EESL utilizing the EMG is as follows:

$$L_{EESL}=\mathrm{ }\sum _{i=1}^3{\left({EMG}_i\right(gt)-{EMG}_i(pred\left)\right)}^2 .$$

(11)

Here, ${EMG}_i\left(gt\right)$ and ${EMG}_i\left(pred\right)$ indicate the feature map extracted from the i-th conv layer presented in Table 3; the ground truth and predicted segmentation masks as the EMG input. We used the MSE to minimize the difference between the two and trained a segmentation network that produces more precise outputs, even from motion-blurred images with damaged edge information due to the loss. Finally, three losses are combined in the proposed KDS-Net: cross-entropy loss and the two aforementioned losses, as shown in Equation (12).

$$L_{total loss}=L_{cross entropy}+L_{distillation}+{\lambda L}_{EESL}$$

(12)

where λ is a balancing parameter to ensure that the losses have a favorable impact on learning; thus, we set λ to 0.05 by conducting the experiment using the training data where the segmentation accuracy is the highest.

3.4. Fractal Dimension Estimation (FDE)

Fractal structures exhibit self-similarity and often deviate from standard geometric representations [26]. The fractal dimension (FD) offers a quantitative measure of structural complexity, indicating whether a shape is more spatially concentrated or dispersed. In this study, we estimate the FD of a specific semantic class (e.g., car, sidewalk, and bicyclist) from semantic segmentation masks. For each selected class, we extract both the ground truth binary mask and the predicted mask produced by our proposed KDS-Net, and perform fractal analysis on each. The FD reflects the level of geometric detail in these binary shapes. A higher FD implies greater contour complexity or spatial irregularity in the segmented region. The FD for each class-specific region is estimated using the box-counting method [27], where N denotes the number of square boxes that intersect the foreground region, and λ is the box scaling factor. In our setting, FD is computed separately for the ground truth mask and the prediction result produced by KDS-Net, both of which are converted to a binary form for a specific semantic class. The FD is determined by the following Equation (13):

$$\mathrm{F}\mathrm{D}=\underset{\lambda \to 0}{\lim }{\displaystyle \frac{\mathrm{l}\mathrm{o}\mathrm{g}\left(N\left(\lambda \right)\right)}{\mathrm{l}\mathrm{o}\mathrm{g}(1/\lambda )}},$$

(13)

where $1\le \mathrm{F}\mathrm{D}\le 2$, and for all $\lambda >0$, there exists an $N\left(\lambda \right)$. The pseudocode for estimating the FD of the activated part of the image using the box-counting method is provided in Algorithm 1.

Algorithm 1 Pseudocode for FDE

Input: BM: Binary masks of a specific semantic class extracted from the ground truth and KDS-Net predictions Output: FD: Fractal dimension 1:  Determine the maximum dimension of the box and round it to the nearest power of 2 Max_dimension = max(size(BM))    $\lambda$ = 2^[log2(Max_dimension)] 2:  If the image size is smaller than $\lambda$, pad the image to match the dimension of $\lambda$    if size(BM) < size($\lambda$)      Pad_width = ((0, $\lambda$ − BM.shape [0]), (0, $\lambda$ − BM.shape [1]))      Pad_BM = pad(BM, Pad_width, mode = ‘constant’, constant_values = 0)    else      Pad_BM = BM 3:  Initialize an array storing the number of boxes for each dimension size n = zeros(1, $\lambda$ + 1) 4:  Compute the number of boxes, N($\lambda )$ containing at least one pixel of the positive region n[$\lambda$ + 1] = sum(BM [:]) 5:  While $\lambda$ > 1:      a. Reduce the size of $\lambda$ by a factor of 2      b. Update the number of boxes N($\lambda )$ 6:  Compute log(N($\lambda )$) and log($1/\lambda$) for each $\lambda$ 7:  Fit a line to the points [(log($1/\lambda$), log(N($\lambda )$)] using the least squares method 8:  FD is determined by the slope of the fitted line Return FD

4. Experimental Results and Analysis

4.1. Experimental Databases and Setup

In this study, we used the two most commonly utilized open road scene semantic segmentation databases, Cambridge driving labeled video (CamVid) [28] and Karlsruhe Institute of Technology and Toyota Technological Institute (KITTI) [29], for the experiment. These databases collectively encompass 12 classes, such as buildings, roads, vehicles, and unlabeled classes, and provide ground truth data for each class. The CamVid database has 701 images, all having the same resolution of 960 $\times$ 720 pixels, whereas the KITTI database contains 445 images having different resolutions. To facilitate a comparison with the SDAN-MD [3], which enhanced semantic segmentation performance in a motion-blurred environment using the CamVid and KITTI databases, we resized the CamVid images to 320 $\times$ 240 pixels and the KITTI images to 512 $\times$ 176 pixels in this study. For consistency, we implemented a two-fold cross-validation [30] during the experiment. The 701 images in the CamVid database were split into subsets A (351 images) and B (350 images), whereas the 445 images in the KITTI database were divided into subsets A (223 images) and B (222 images). During the first fold validation, we used subset A of each database as the training set and subset B as the testing set. For the second fold validation, we swapped subsets A and B and computed the average performance. Furthermore, we randomly selected 1/10 of the training set as the validation set in this study. Several databases, such as GoPro [31] and Hide [32], generate artificially blurred images, whereas the RealBlur database [33] captures blurred images in real-world environments. However, none of these databases provide ground truth segmentation labels. Because no databases containing motion-blurred images with ground truth segmentation labels exist, we created motion-blurred images by applying Kupyn et al.’s method [34] to the CamVid and KITTI databases. The primary goal was to enhance semantic segmentation performance in motion-blurred images captured by using a vehicle’s front-viewing camera. Thus, we constructed a motion-blurred road scene image database using the CamVid and KITTI road scene databases, both including ground truth segmentation labels, as depicted in Figure 5.

For training, we employed online data augmentation techniques, including random crop, color jitter, and horizontal flip [35]. Random crop involves selecting a random portion of an image at a specified patch size for cropping during each training iteration. Random color jitter involves randomly altering the lightness, hue, and saturation of an image. Random horizontal flip entails flipping an image horizontally with a random probability. The random color jitter technique was used owing to the mixed nature of the dataset, containing both dark and bright images. Horizontal flip was preferred over vertical flip because, in road scene databases, vehicles, pedestrians, and bicycles are unlikely to appear in the upper part of an image or in the sky. Detailed information about the databases used in this study is presented in

Table 4. Summary of experimental databases containing motion-blurred images. # indicates the number of images.

Database		# Images	Size	Class Names (Ratio %)
CamVid	Subset A	351	320 $\times$ 240	Sky (15.81), Building (24.10), Pole (0.99), Road (29.33), Sidewalk (6.69), Tree (11.19), Sign symbol (1.08), Fence (1.43), Car (4.64), Pedestrian (0.64), Bicyclist (0.53), Unlabeled (3.57)
	Subset B	350
KITTI	Subset A	223	512 $\times$ 176	Sky (5.89), Building (20.91), Road (17.01), Sidewalk (7.22), Fence (3.14), Tree (34.58), Pole (0.51), Car (7.34), Sign symbol (0.36), Pedestrian (0.07), Bicyclist (0.12), Unlabeled (2.85)
	Subset B	222

.

Our experiments were conducted on a desktop computer equipped with an Intel^® Core™ i7-6700 (Intel Corp., Santa Clara, CA, USA) central processing unit (CPU) and 16 GB of RAM (Samsung Electronics Co., Ltd., Suwon City, Gyeonggi-do, Republic of Korea), alongside an NVIDIA GeForce RTX 3060 (NVIDIA Corp., Santa Clara, CA, USA) graphics processing unit (GPU) with 12 GB of graphics memory [36]. The computer ran on an Ubuntu 20.04.3 operating system. The training and testing algorithms of our network were implemented using the PyTorch framework (version 1.12.1) [37].

4.2. Training of KDS-Net

For training the proposed KDS-Net, we employed the adaptive moment estimation (Adam) optimizer [38] as a method for optimizing weight parameters. The initial learning rate was 0.0001, with beta 1 and beta 2 set to 0.9 and 0.999, respectively, and epsilon set to 10⁻⁸. Additionally, we ensured that the initial learning rate decreased by a factor of 0.1 at each step. The batch size was set to 4, and the number of epochs was set to 400. The CamVid database was trained on images resized to 224 $\times$ 224 pixels, whereas the KITTI database was trained on a patch size of 160 $\times$ 160 pixels. As summarized in

Table 5. Training time per epoch for different datasets and models (unit: seconds).

Database	Model	Training Time per Epoch
CamVid	Teacher model	82.98
	Student model	57.32
KITTI	Teacher model	49.68
	Student model	32.51

, the teacher model and student model demonstrated different training times per epoch for both databases. As shown in Figure 1, the teacher model required significantly more time due to the training process involving both motion-blurred images and their corresponding restored versions, effectively doubling the amount of data processed. On the other hand, while the student model incurred additional time for knowledge distillation from the teacher model, it only processed motion-blurred images directly, resulting in comparatively reduced training time. Figure 6 reveals the training and validation losses and their corresponding accuracies across the epochs during the training of the proposed KDS-Net. As the number of epochs increased, the training loss approached zero and the training accuracy converged to a sufficiently high value, indicating that our network was stably trained on the training dataset. Furthermore, as the number of epochs increased, the validation loss converged to a small value and the corresponding accuracy to a large value, indicating that our network did not overfit the training data.

4.3. Testing of Proposed Method

4.3.1. Evaluation Metrics

In this study, to compare our proposed network with other networks, we utilized five commonly used semantic segmentation evaluation metrics from existing research, as shown in Equations (14)–(18): pixel accuracy (PA), mean pixel accuracy (mPA), class intersection over union (Class IoU), frequency-weighted intersection over union (FW IoU), and mean intersection over union (mIoU) [39,40].

$$PA={\displaystyle \frac{\sum _{i=0}^K{n}_{ii}}{\sum _{i=0}^K{c}_i}}$$

(14)

$$mPA={\displaystyle \frac{1}{K+1}} \sum _{i=0}^K{\displaystyle \frac{n_{ii}}{c_i}}$$

(15)

$$\mathit{Class}\mathit{IoU}={\displaystyle \frac{n_{ii}}{c_i+{\sum }_{j=0}^K{n}_{ji}-n_{ii}}}$$

(16)

$$FW IoU={\left(\sum _{k=0}^K{c}_k\right)}^{-1}\sum _{i=0}^K{c}_i{Class IoU}_i$$

(17)

$$mIoU={\displaystyle \frac{1}{K+1}} \sum _{i=0}^K{\displaystyle \frac{n_{ii}}{c_i+{\sum }_{j=0}^K{n}_{ji}-n_{ii}}}$$

(18)

In each equation, K + 1 represents the number of classes, and $c_i$ denotes the total number of pixels in the i-th class. $n_{ii}$ represents the number of pixels correctly classified as the i-th class, while $n_{ji}$ indicates the number of pixels of the i-th class, being misclassified as the j-th class. Equation (14), PA represents the ratio of correctly classified pixels to the total number of pixels. Equation (15), mPA denotes the average value obtained by dividing the PA calculated for each class by the total number of classes.

Equation (16), Class IoU_i, represents the ratio of the number of common pixels between the ground truth and prediction for the i-th class to the total number of pixels. While PA and mPA do not account for incorrect classes, Class IoU_i decreases as the number of incorrect classes increases because the denominator becomes larger. If there is a significant difference in the number of pixels per class and a greater emphasis is desired for classes with more pixels, Equation (17), FW IoU is used. FW IoU multiplies the pixel frequency of each class by the Class IoU_i. Due to class imbalance in the databases used in this study, CamVid and KITTI, we additionally employed this evaluation metric. Lastly, Equation (18), mIoU, represents the average of Class IoU_i across all classes, calculated by summing the Class IoU_i and dividing by the number of classes.

4.3.2. Testing on CamVid Database

Ablation Studies

In this study, we conducted a total of three types of ablation studies.

Table 6. Cases for the first ablation study according to the usage of proposed modules in KDS-Net. The ✓ indicates that the module is included.

Method	SCM	FAFM	EMG	KD	VQ
Case 1
Case 2	✓
Case 3	✓	✓
Case 4	✓	✓	✓
Case 5	✓	✓	✓	✓
Case 6 (proposed)	✓	✓	✓	✓	✓

presents the setup for the first ablation study, while

Table 7. Performance comparisons for the first ablation study (unit: %).

Method	PA	mPA	FW IoU	mIoU
Case 1	90.72	66.27	83.54	59.19
Case 2	91.10	69.93	84.24	61.25
Case 3	91.62	72.78	85.18	63.86
Case 4	92.37	75.41	86.40	66.62
Case 5	93.56	79.13	88.33	71.66
Case 6 (proposed)	93.69	79.80	88.56	72.42

shows the performance results for each case described in Table 6. In Table 6, VQ represents vector quantization. The results, as seen in Table 6 and Table 7, indicate that Case 6, which incorporates all the methods proposed in this study, achieved the highest semantic segmentation performance. This confirms that the methods proposed in this study enhance semantic segmentation performance for road scene images in environments with motion blur.

We conducted a second ablation experiment on EMG using the method from Case 6 in Table 6 (proposed method). Each case in

Table 8. Cases for the second ablation study according to the number of layers where feature maps are extracted in EMG. The ✓ indicates that the layer is included.

Method	1st Layer	2nd Layer	3rd Layer
Case 1	✓
Case 2		✓
Case 3			✓
Case 4	✓	✓
Case 5		✓	✓
Case 6 (proposed)	✓	✓	✓

indicates from which of the three layers in Figure 4 and Table 3 the feature map was extracted in EMG.

Table 9. Performance comparisons for the second ablation study (unit: %).

Method	PA	mPA	FW IoU	mIoU
Case 1	92.88	77.78	87.24	69.65
Case 2	93.17	77.66	87.68	70.21
Case 3	93.18	77.18	87.66	70.03
Case 4	93.30	77.71	87.87	70.04
Case 5	93.41	79.26	88.11	71.58
Case 6 (proposed)	93.69	79.80	88.56	72.42

presents the semantic segmentation performance corresponding to each case. As seen in Table 8 and Table 9, the EESL, which is the loss using EMG, achieved the best performance when feature maps from all layers of the EMG were used.

Lastly, we conducted an ablation study on the dense block of Figure 2 and Table 1, where features were extracted from the encoder of both the teacher model and the student model during the KD process.

Table 10. Cases for the third ablation study according to the usage of dense block (DB) of the encoder in KDS-Net. The ✓ indicates that the block is included.

Method	DB (X1,0)	DB (X2,0)	DB (X3,0)	DB (X4,0)
Case 1	✓
Case 2		✓
Case 3			✓
Case 4				✓
Case 5 (proposed)	✓	✓	✓	✓

presents the various cases for the third ablation study, and

Table 11. Performance comparisons for the third ablation study (unit: %).

Method	PA	mPA	FW IoU	mIoU
Case 1	92.73	75.22	86.91	67.74
Case 2	92.91	75.68	87.22	68.58
Case 3	92.94	76.76	87.23	69.27
Case 4	93.05	76.45	87.43	69.41
Case 5 (proposed)	93.56	79.13	88.33	71.66

shows the semantic segmentation performance for each case.

As seen in Table 10 and Table 11, we observed that performance improves as deeper encoder blocks of both the teacher model and the student model are used during KD. Additionally, using all encoder blocks yielded better performance compared to using only a single encoder block.

Comparative Experiments Between the Proposed and State-of-the-Art (SOTA) Methods

In this subsection, we compared the proposed KDS-Net with state-of-the-art (SOTA) methods. The SOTA methods were categorized into those that include an image blur restoration process and those that do not, with the proposed method not including a restoration process. In all experiments, for methods that include an image blur restoration process without semantic segmentation, the DeepLabV3-Plus method was used as the semantic segmentation network for performance comparison.

Table 12. Comparison of semantic segmentation accuracies using the proposed and SOTA methods on the CamVid database (unit: %). W restoration refers to “with restoration,” W/O restoration refers to “without restoration,” and W KD refers to “with knowledge distillation.”.

Method		PA	mPA	FW IoU	mIoU
W restoration	DeblurGAN-V2 [34]	91.54	71.75	85.04	64.69
	MPRNet [41]	91.01	72.10	83.90	64.67
	HINet [42]	91.54	72.85	84.83	65.47
	MIMO-UNet [43]	90.41	69.44	82.93	61.97
	MIMO-UNet-Plus [43]	90.66	70.17	83.34	62.76
	DeepRFT [44]	92.08	74.03	85.73	66.64
	DeepRFT-Plus [44]	92.00	75.85	86.98	68.62
	Attentive deep [45]	90.91	70.47	83.77	63.28
	MHNet [46]	90.58	70.01	83.26	62.67
	SDAN-MD [3]	92.89	76.82	87.10	69.58
W/O restoration	PSPNet [47]	88.98	64.56	80.65	56.04
	ICNet [11]	88.29	62.39	79.60	54.27
	DeeplabV3-Plus [14]	89.45	67.18	81.51	59.25
	UperNet [48]	91.01	71.03	84.00	63.15
	Alpha blending [15]	88.93	65.68	80.72	57.95
	SPNet [49]	92.70	75.05	86.85	67.91
	HRNet [16]	92.63	76.27	86.72	68.81
	SegFormer [50]	92.78	75.38	86.96	67.95
	DDRNet [51]	91.65	73.73	85.96	66.21
W/O restoration and W KD	Teacher	94.33	80.72	89.55	74.76
	Student	92.37	75.41	86.40	66.62
	Fitnet [52]	92.30	72.31	86.14	65.85
	AT [53]	91.23	69.29	84.37	63.11
	SP [54]	92.20	74.03	86.10	66.80
	ReviewKD [55]	92.40	74.34	86.34	67.57
	SimKD [56]	92.37	74.36	86.28	67.44
	KDS-Net (ours)	93.69	79.80	88.56	72.42

compares PA, mPA, FW IoU, and mIoU for each method, while

Table 13. Comparison of semantic segmentation accuracy (Class IoU) using the proposed and SOTA methods according to classes on the CamVid database (unit: %).

Method		Sky	Building	Pole	Road	Sidewalk	Tree	Sign	Fence	Car	Pedestrian	Bicyclist
W restoration	DeblurGAN-V2 [34]	90.85	84.87	14.35	94.75	76.07	76.48	42.78	53.91	82.56	33.62	61.34
	MPRNet [41]	89.26	83.14	18.07	95.62	79.21	67.92	41.57	48.82	83.74	40.16	63.91
	HINet [42]	89.61	84.64	17.17	95.47	78.86	72.37	42.40	51.99	83.97	38.60	65.05
	MIMO-UNet [43]	89.03	82.32	15.06	94.90	76.46	68.10	38.11	41.14	81.81	34.56	60.17
	MIMO-UNet-Plus [43]	89.36	82.65	15.70	95.13	77.44	68.52	38.96	42.81	82.38	35.83	61.54
	DeepRFT [44]	90.40	85.75	17.35	95.57	79.34	75.03	43.44	55.34	84.85	40.47	65.60
	DeepRFT-Plus [44]	91.16	87.08	18.51	95.98	80.97	78.03	45.85	60.60	85.94	43.13	67.55
	Attentive deep [45]	89.25	83.46	16.21	94.99	77.15	70.43	38.26	48.32	82.62	35.28	60.12
	MHNet [46]	89.06	82.76	15.64	94.81	76.32	69.56	37.59	46.29	81.68	34.63	61.02
	SDAN-MD [3]	90.88	87.09	20.99	96.34	82.45	76.64	48.86	60.84	86.77	45.37	69.21
W/O restoration	PSPNet [47]	88.25	80.40	2.62	92.75	68.87	71.46	23.38	42.53	71.56	24.26	50.32
	ICNet [11]	88.24	78.45	2.37	92.15	66.75	70.35	21.34	43.23	71.23	17.34	41.51
	DeeplabV3-Plus [14]	86.52	81.51	11.58	93.59	72.74	69.75	32.98	40.69	77.94	30.20	54.20
	UperNet [48]	89.13	83.72	9.31	94.83	76.56	74.08	34.50	56.00	78.74	34.86	58.89
	Alpha blending [15]	87.95	80.04	12.03	92.72	69.88	69.79	28.49	41.09	75.26	29.75	50.48
	SPNet [49]	90.39	86.92	15.46	96.18	82.14	78.06	42.93	65.42	84.19	39.99	65.32
	HRNet [16]	90.91	86.56	23.28	95.95	81.44	77.78	45.14	62.45	83.05	43.62	66.74
	SegFormer [50]	91.13	86.91	12.55	96.01	81.41	79.28	46.42	64.01	83.47	41.39	64.94
	DDRNet [51]	90.35	85.78	15.33	95.85	80.60	76.87	41.01	59.22	82.02	38.99	63.12
W/O Restoration and W KD	Teacher	91.60	89.84	25.64	97.08	86.53	82.56	62.34	73.17	86.84	53.14	73.65
	Student	86.95	86.34	8.79	95.57	81.31	77.82	50.99	60.00	79.79	41.75	63.51
	Fitnet [52]	90.90	85.66	18.46	95.99	80.82	77.95	47.75	58.67	80.10	30.29	57.81
	AT [53]	90.15	83.02	16.01	95.50	79.29	76.58	46.76	50.60	71.55	31.47	53.29
	SP [54]	90.78	86.02	21.48	96.14	81.70	76.03	50.23	50.78	79.56	41.38	60.70
	ReviewKD [55]	90.75	86.58	24.56	95.86	81.03	77.18	51.20	53.66	79.76	42.37	60.28
	SimKD [56]	91.03	86.47	25.04	95.73	80.73	77.37	50.57	54.76	78.85	41.93	59.34
	KDS-Net (ours)	91.57	88.49	27.42	96.77	84.63	80.77	54.00	67.28	86.42	48.32	70.94

compares Class IoU for each class within the images. Note that the student in Table 12 corresponds to Case 4 from Table 6 and Table 7. The teacher, on the other hand, is the model responsible for providing knowledge distillation, as explained in Figure 1 and Table 5.

As shown in Table 12, the proposed KDS-Net achieves the highest performance across all metrics, surpassing both the methods that include an image restoration process and those that do not. Additionally, as observed in Table 13, the proposed KDS-Net outperforms in all classes except for the car class. This can be attributed to the fact that SDAN-MD [3] includes a restoration process as part of its segmentation pipeline, which may enhance its performance specifically for the car class compared to our proposed method.

Figure 7 visually presents the semantic segmentation results of the proposed method compared to the SOTA methods. While the segmentation results using other SOTA methods show reasonable performance for classes such as road, car, and sidewalk, the segmentation performance for smaller objects is significantly lower. In contrast, the proposed KDS-Net demonstrates high segmentation performance even for smaller objects such as poles and sign symbols.

Analysis of Feature Maps by Gradient-Weighted Class Activation Mapping (Grad-CAM)

In this subsection, we used Grad-CAM [57] to visualize and compare the feature maps extracted by the proposed KDS-Net and state-of-the-art (SOTA) methods. In Grad-CAM, important features are typically displayed in reddish and yellowish colors. However, this saliency information is represented as a continuous heatmap rather than a discrete mask. As such, it is inherently ambiguous to define a strict threshold that distinguishes important feature regions from less relevant ones. This ambiguity makes it difficult to compute quantitative metrics such as the intersection over union (IoU) between the Grad-CAM activation map and the actual value. Therefore, we adopt a qualitative interpretation strategy, focusing on whether the model’s attention aligns with semantically meaningful regions rather than enforcing a direct spatial correspondence with the actual value.

In this study, we compared the feature map extracted from the final output layer of each segmentation network. For restoration models, the restored images were used as input to the segmentation network, and the feature maps were similarly extracted from the final layer for comparison. As shown in Table 13, the performance for the pole and pedestrian classes was the lowest when measuring the performance for each class. Therefore, we extracted and compared the feature maps for the pole and pedestrian classes.

Figure 8 shows the feature maps extracted for the pole class (a) and the pedestrian class (b), with comparisons across the different methods. The results, as illustrated in Figure 8, demonstrate that the feature maps extracted by the proposed KDS-Net are more similar to the ground truth than those extracted by other networks. This confirms that the KDS-Net improves semantic segmentation accuracy in motion-blurred environments compared to the state-of-the-art (SOTA) methods.

4.3.3. Testing on KITTI Database

Comparative Experiments Between the Proposed and SOTA Methods

In this subsection, we compared the semantic segmentation performance of the proposed KDS-Net with other state-of-the-art (SOTA) methods using another road scene database, KITTI.

Table 14. Comparison of semantic segmentation accuracies using the proposed and SOTA methods on the KITTI database (unit: %).

Method		PA	mPA	FW IoU	mIoU
W restoration	DeblurGAN-V2 [34]	84.48	56.53	74.06	48.73
	MPRNet [41]	84.56	55.50	73.66	48.33
	HINet [42]	85.59	60.70	75.29	52.29
	MIMO-UNet [43]	84.12	53.48	72.22	46.00
	MIMO-UNet-Plus [43]	84.17	54.64	73.03	47.22
	DeepRFT [44]	85.20	59.70	74.60	50.82
	DeepRFT-Plus [44]	86.86	62.05	77.19	53.82
	Attentive deep [45]	82.87	52.32	71.16	44.70
	MHNet [46]	84.02	55.91	72.88	48.03
	SDAN-MD [3]	87.27	63.56	77.84	55.59
W/O restoration	PSPNet [47]	82.75	52.15	71.51	43.58
	ICNet [11]	77.98	45.69	65.30	36.54
	DeeplabV3-Plus [14]	83.39	53.57	71.99	45.77
	UperNet [48]	87.66	61.16	78.45	53.69
	Alpha blending [15]	78.97	52.11	65.57	43.02
	SPNet [49]	88.07	59.53	79.02	52.69
	HRNet [16]	88.07	62.37	79.33	54.31
	SegFormer [50]	87.67	55.99	77.73	48.99
	DDRNet [51]	87.18	59.64	77.71	52.14
W/O restoration and W KD	Teacher	93.44	66.91	87.84	62.10
	Student	89.29	62.67	80.98	55.60
	Fitnet [52]	89.37	64.06	81.32	55.96
	AT [53]	89.40	62.75	81.25	55.41
	SP [54]	89.62	62.95	81.62	56.05
	ReviewKD [55]	89.60	67.19	81.71	57.74
	SimKD [56]	89.76	62.95	81.77	56.23
	KDS-Net (ours)	90.10	66.61	82.36	59.29

compares PA, mPA, FWIoU, and mIoU, while

Table 15. Comparison of semantic segmentation accuracy (Class IoU) using the proposed and SOTA methods according to classes on the KITTI database (unit: %).

Method		Sky	Building	Road	Sidewalk	Fence	Tree	Pole	Car	Sign	Pedestrian	Bicyclist
W restoration	DeblurGAN-V2 [34]	87.15	73.24	79.03	51.62	35.96	80.54	7.50	70.92	23.58	16.09	10.38
	MPRNet [41]	85.80	71.02	80.76	53.04	28.89	79.96	15.27	72.92	24.64	14.30	5.05
	HINet [42]	83.94	72.55	82.93	57.03	36.90	80.45	15.58	76.43	27.89	29.95	11.60
	MIMO-UNet [43]	84.12	70.39	79.49	50.64	23.54	79.13	8.95	69.28	19.07	16.71	4.70
	MIMO-UNet-Plus [43]	85.27	71.25	80.09	51.65	25.28	79.63	10.06	70.85	19.83	16.39	9.14
	DeepRFT [44]	85.99	72.62	81.53	54.70	31.73	80.01	14.26	73.40	26.32	26.81	11.35
	DeepRFT-Plus [44]	87.23	75.82	83.13	57.10	39.54	82.43	15.27	74.15	29.69	30.69	12.42
	Attentive deep [45]	81.77	69.13	78.24	50.19	26.17	78.65	9.87	65.36	15.10	14.77	2.52
	MHNet [46]	84.13	70.24	80.37	53.15	28.73	79.23	13.38	70.60	22.30	20.82	5.38
	SDAN-MD [3]	87.86	75.66	84.10	59.13	39.53	82.53	18.11	82.08	31.10	35.42	15.95
W/O restoration	PSPNet [47]	79.65	71.95	74.73	48.67	30.55	79.43	7.69	67.80	15.08	2.18	1.68
	ICNet [11]	81.12	69.62	56.76	38.78	14.58	78.28	1.03	55.71	6.01	0.00	0.00
	DeeplabV3-Plus [14]	80.43	69.99	79.46	52.03	29.13	79.58	10.50	64.33	19.63	13.17	5.18
	UperNet [48]	87.61	78.19	86.16	58.53	42.60	84.74	14.71	73.44	28.57	24.40	14.17
	Alpha blending [15]	78.84	65.70	74.57	43.52	28.18	69.12	11.77	62.32	19.69	11.46	8.09
	SPNet [49]	87.45	78.23	85.45	60.02	43.44	84.53	12.20	76.23	25.76	12.62	13.66
	HRNet [16]	88.43	78.22	85.42	61.89	42.13	84.29	21.31	79.03	27.11	17.28	12.16
	SegFormer [50]	87.96	77.13	83.61	57.85	39.28	84.31	8.49	72.29	19.58	5.58	2.80
	DDRNet [51]	86.68	76.65	84.35	59.69	37.47	83.20	16.87	75.82	25.00	16.55	11.27
W/O Restoration and W KD	Teacher	91.12	86.36	94.15	81.53	70.49	89.64	16.09	88.52	56.36	6.77	2.04
	Student	86.51	78.64	86.93	64.50	50.48	86.25	14.03	82.13	39.69	13.56	8.82
	Fitnet [52]	87.51	79.22	87.47	65.88	48.26	86.45	13.48	81.65	40.60	12.99	12.10
	AT [53]	88.10	79.44	86.97	65.41	47.86	86.35	12.08	82.04	38.16	10.39	12.73
	SP [54]	88.13	79.78	87.97	66.88	48.22	86.22	18.37	82.18	39.12	11.66	8.03
	ReviewKD [55]	88.51	79.45	87.76	66.50	49.99	86.42	22.50	82.60	42.75	16.53	12.08
	SimKD [56]	87.92	79.67	88.37	67.52	48.42	86.28	19.08	92.77	37.15	12.85	8.54
	KDS-Net (ours)	89.81	81.45	87.63	66.42	50.87	86.53	23.25	84.14	38.99	25.51	17.58

compares the Class IoU for all classes. From Table 14, it can be seen that the proposed KDS-Net achieves the highest semantic segmentation accuracies compared to the SOTA methods. Additionally, as indicated in Table 15, although our proposed method does not achieve the best performance for all classes, it demonstrates higher accuracy for most classes on the KITTI database. Figure 9 visually presents the semantic segmentation results of the proposed method and the SOTA methods. As observed in Figure 9, the proposed KDS-Net produces results that are most similar to the ground truth when tested on the KITTI database, outperforming the other methods.

Analysis of Feature Maps by Grad-CAM

We used the KITTI database to extract and analyze the feature maps of the proposed KDS-Net and state-of-the-art (SOTA) methods using Grad-CAM. As previously mentioned, important features in Grad-CAM are typically displayed in reddish and yellowish colors. We conducted experiments on the two classes with the lowest performance as indicated in Table 15, and extracted feature maps from the final layer of the semantic segmentation networks, as described in the section Analysis of Feature Maps by Gradient-Weighted Class Activation Mapping (Grad-CAM). Figure 10a shows the Grad-CAM image for the pedestrian class, and Figure 10b shows the Grad-CAM image for the bicyclist class. As shown in Figure 10, when comparing the Grad-CAM images of the proposed KDS-Net with other SOTA methods, it is evident that the other methods do not properly focus on the relevant class regions. In contrast, the KDS-Net effectively focuses on the relevant class regions, producing results that most closely resemble the ground truth. This confirms that the proposed KDS-Net improves semantic segmentation performance for motion-blurred images more effectively than the SOTA methods.

Comparisons of Inference Time and Computational Cost

In this subsection, we compared the inference time per image of the proposed KDS-Net with state-of-the-art (SOTA) methods. The inference time was measured on both a desktop computer and a Jetson TX2 embedded system. As shown in Figure 11, the Jetson TX2 features an NVIDIA Pascal™ family GPU (256 CUDA cores), 8 GB of memory shared between the CPU and GPU, and a memory bandwidth of 59.7 GB/s. Additionally, it uses less than 7.5 watts of power. The specifications of the desktop computer are described in Section 4.1. The reason for measuring on the Jetson TX2 embedded system is that road scene segmentation is often performed using a camera mounted on a vehicle. In such cases, the algorithm operates as edge computing within the vehicle’s embedded system for edge intelligence-empowered internet of vehicles. Therefore, to verify whether the proposed system can operate on an embedded system, we conducted experiments on the Jetson TX2 embedded system and compared the results with SOTA methods, as shown in

Table 16. Comparison of the inference time per one image (unit: ms) and inference speed (unit: frames per second (fps)) by proposed and SOTA methods on the desktop and embedded system.

Method		Inference Time/Inference Speed
		Desktop	Jetson Embedded System
W restoration	DeblurGAN-V2 [34]	40.94/24.43	198.98/5.03
	MPRNet [41]	47.52/21.04	551.79/1.81
	HINet [42]	18.55/53.91	92.39/10.82
	MIMO-UNet [43]	21.04/47.53	101.18/9.88
	MIMO-UNet-Plus [43]	35.63/28.07	308.77/3.24
	DeepRFT [44]	37.62/26.58	420.53/2.38
	DeepRFT-Plus [44]	77.87/12.84	1400.37/0.71
	Attentive deep [45]	66.65/15.00	704.97/1.42
	MHNet [46]	56.01/17.85	387.12/2.58
	SDAN-MD [3]	48.68/20.54	648.44/1.54
W/O restoration	PSPNet [47]	8.45/118.34	41.63/24.02
	ICNet [11]	13.48/74.18	57.39/17.42
	DeeplabV3-Plus [14]	7.47/133.87	41.46/24.12
	UperNet [48]	8.24/121.36	42.52/23.52
	Alpha blending [15]	7.45/134.23	41.46/24.12
	SPNet [49]	17.93/55.77	74.89/13.35
	HRNet [16]	40.61/24.62	154.00/6.49
	SegFormer [50]	6.29/158.98	31.64/31.61
	DDRNet [51]	6.94/144.09	27.01/37.02
	Proposed (KDS-Net)	6.29/158.98	32.18/31.08

. For the methods using restoration models, the inference time was measured by summing the inference time of the restoration process and the segmentation process.

The inference time per image measured with the proposed method was 6.29 ms (milliseconds) on the desktop computer and 37.18 ms on the Jetson embedded system, corresponding to processing speeds of approximately 159 frames per second (fps) and 31.1 fps, respectively. This confirms that the proposed method can operate on an embedded system with limited computing resources at real-time speed. Additionally, as shown in Table 16, the processing time of the proposed method was the lowest on the desktop computer and the third lowest on the Jetson embedded system compared to the SOTA methods.

In

Table 17. Comparison of number of parameters, GPU memory, FLOPs of KDS-Net, and SOTA methods. # indicates the number of parameters.

Method		# Parameters (Unit: Mega)	GPU Memory Requirement (Unit: Mega Byte)	FLOPs (Unit: Giga)
W restoration	DeblurGAN-V2 [34]	44.85	678.81	102.4
	MPRNet [41]	59.89	1306.02	1982.4
	HINet [42]	128.43	678.81	464.16
	MIMO-UNet [43]	46.57	1149.11	205.52
	MIMO-UNet-Plus [43]	55.87	2024.62	423.82
	DeepRFT [44]	49.31	2009.62	48.82
	DeepRFT-Plus [44]	62.73	4176.38	49.70
	Attentive deep network [45]	46.67	7497.51	542.73
	MHNet [46]	56.79	5276.01	157.34
	SDAN-MD [3]	60.09	7719.86	2363.33
W/O restoration	PSPNet [47]	48.76	548.73	115.57
	ICNet [11]	28.30	186.28	28.30
	DeeplabV3-Plus [14]	39.76	333.51	37.38
	UperNet [48]	37.28	349.12	47.98
	Alpha blending [15]	39.76	333.51	37.38
	SPNet [49]	60.61	895.58	155.16
	HRNet [16]	65.85	622.52	58.72
	SegFormer [50]	3.72	105.16	4.26
	DDRNet [51]	5.73	56.59	3.06
	Proposed (KDS-Net)	21.44	607.74	112.42

, we compare the number of parameters, GPU memory requirements, and floating-point operations (FLOPs) of the proposed KDS-Net and the state-of-the-art (SOTA) methods. Although the proposed KDS-Net does not have the lowest computational cost, it achieves the highest semantic segmentation accuracy, as demonstrated in Table 12, Table 13, Table 14 and Table 15 and Figure 7, Figure 8, Figure 9, Figure 10 and Figure 11, aligning with the primary objective of this study.

5. Discussions

5.1. Statistical Analysis

We conducted a t-test to examine the statistical significance of the performance difference between the proposed KDS-Net and the second-best method (SDAN-MD), as shown in Table 12. Additionally, we evaluated the practical significance using Cohen’s d-value [58] as the effect size measure. A Cohen’s d-value close to 0.2 indicates a small effect size, close to 0.5 indicates a medium effect size, and close to 0.8 indicates a large effect size. A large effect size suggests that the difference between the two groups is practically significant.

As shown in Figure 12, p-values for PA, mPA, FW IoU, and mIoU are 0.14 × 10⁻¹, 0.09 × 10⁻¹, 0.05 × 10⁻¹, and 0.005 × 10⁻¹, respectively. This indicates that the performance difference between our proposed KDS-Net and the second-best method is statistically significant at a 95% confidence level for PA and at a 99% confidence level for all the remaining evaluation metrics. Additionally, the Cohen’s d-values measured between the proposed method and the second-best method are 16.06, 24.83, 41.15, and 400.92, respectively, all indicating a large effect size. These results confirm that our proposed method demonstrates significantly higher accuracy compared to the second-best method.

5.2. Analysis of Error Cases by Proposed Method

In this subsection, we analyzed the error cases of the proposed method. One of the error cases identified in our proposed method is the issue of class imbalance, which is particularly caused by the objects that occupy a small portion of the image, such as poles and pedestrians. These classes play a crucial role in various applications, including autonomous driving, but they appear less frequently in the training dataset compared to larger classes such as roads and buildings.

Due to this class imbalance, as shown in Figure 13, our proposed KDS-Net sometimes fails to accurately segment small objects such as poles and pedestrians. Semantic segmentation involves pixel-level classification, and IoU measures how well the predicted pixels overlap with the ground truth pixels. Therefore, for classes with a small number of pixels, the network finds it challenging to learn fine details and achieve high segmentation accuracy. Conversely, classes with a larger number of pixels are easier for the network to learn and segment accurately.

This issue, caused by class imbalance within the dataset, can lead to significant safety concerns in real-world applications such as with autonomous vehicles. Consequently, future research should focus on exploring various approaches to address this problem, thereby improving model accuracy and ensuring safety in real-world environments.

5.3. FD Analysis for Class-Wise Segmentation Quality

The FD analysis was performed on the binary masks corresponding to a specific semantic class (e.g., car, bicyclist), extracted from both the ground truth and the KDS-Net predictions. To compute the FD score, the box-counting method described in Algorithm 1 of Section 3.4 was applied.

Figure 14 illustrates the FD analysis for four different semantic classes. For each class, we extract binary masks from both the ground truth annotations and the predictions made by KDS-Net, and present the corresponding FD estimation plots for each case. These plots report the FD score, correlation coefficient (C) between the log of 1/box size (log $(1/\lambda )$ ) and box count (log(N(λ)), and the coefficient of determination (R²) for the fitted regression line. The FD scores quantify the complexity of each class-specific shape within the segmentation mask. The FD scores serve as a quantitative indicator of the structural complexity of object shapes within segmentation masks. In the case of car class, as shown in Figure 14a, the FD value for the ground truth is 1.41403, while the value estimated from the predicted mask by KDS-Net is 1.41657. Both cases show strong C values, with 0.99109 for the ground truth and 0.99102 for the prediction, and the corresponding R² values are 0.98226 and 0.98211, respectively. These results indicate that the predicted shape closely mirrors the geometric characteristics of the ground truth annotation. In Figure 14b, the bicyclist class typically associated with more irregular and narrow structures shows a ground truth FD of 1.32727 and a predicted FD of 1.33675. Despite the potential complexity of this category, the C values remain strong, with 0.98632 for the ground truth and 0.98695 for the prediction. Similarly, the R² values are 0.97282 and 0.97406, demonstrating a reliable and well-fitting log-log regression in both cases. For the sidewalk class depicted in Figure 14c, the ground truth FD is 1.40099, and the predicted FD is 1.39811. The C values are 0.99118 for the ground truth and 0.99133 for the prediction, with corresponding R² values of 0.98244 and 0.98273. This indicates a strong alignment between the structural properties of the two masks. In Figure 14d, the sign symbol class yields a ground truth FD of 1.47055 and a predicted FD of 1.47309. The C values are 0.99438 and 0.99556 for the ground truth and prediction, respectively, while the R² values are 0.98880 and 0.99115, respectively. These consistently high metrics demonstrate that KDS-Net can accurately preserve the fine-grained details even in small, intricate object categories. Taken together, these results confirm that the proposed method exhibits high structural fidelity across diverse semantic categories. The minimal differences in FD values, along with strong correlation and regression performance, support the method’s effectiveness in preserving the geometrical traits of segmented objects.

Although the estimation of FD could be integrated into the training metric as a regularizer in principle, this integration entails several practical limitations. To compute FD during training, class-wise binary masks should be generated for each semantic category (class). Given that our datasets contain 12 classes, FD should be estimated individually per class at each training iteration, which substantially increases computational cost and implementation complexity.

Furthermore, integrating FD-based training loss terms on a per-class basis can lead to optimization imbalance, as the network may become biased toward classes with more geometrically complex or spatially dominant structures. This behavior diverges from conventional training loss formulations that treat all classes jointly and uniformly. Based on these considerations, we utilize FD estimation only in a post-hoc manner, where it serves as a structural similarity metric to evaluate the segmentation accuracy of predicted mask compared to ground truth one in terms of complexity and geometric detail, as shown in Figure 14 and

Table 18. R², C and FD values from Figure 14.

Results		R2	C	FD
Figure 14a	Ground truth	0.98226	0.99109	1.41403
	Predict	0.98211	0.99102	1.41657
Figure 14b	Ground truth	0.97282	0.98632	1.32727
	Predict	0.97406	0.98695	1.33675
Figure 14c	Ground truth	0.98244	0.99118	1.40099
	Predict	0.98273	0.99133	1.39811
Figure 14d	Ground truth	0.98880	0.99438	1.47055
	Predict	0.99115	0.99556	1.47309

.

5.4. Comparisons of Proposed Method with SOTA Motion Deblurring Researches

To evaluate the effectiveness of our proposed method under motion blur conditions, we conducted a comprehensive comparison using the CamVid and KITTI datasets. As shown in

Table 19. Comparison of semantic segmentation accuracies using the proposed and SOTA methods on the CamVid database (unit: %).

Method	PA	mPA	FW IoU	mIoU
DeblurGAN-V2 [34]	91.54	71.75	85.04	64.69
MPRNet [41]	91.01	72.10	83.90	64.67
HINet [42]	91.54	72.85	84.83	65.47
MIMO-UNet [43]	90.41	69.44	82.93	61.97
MIMO-Unet-Plus [43]	90.66	70.17	83.34	62.76
DeepRFT [44]	92.08	74.03	85.73	66.64
DeepRFT-Plus [44]	92.00	75.85	86.98	68.62
Attentive deep [45]	90.91	70.47	83.77	63.28
MHNet [46]	90.58	70.01	83.26	62.67
SDAN-MD [3]	92.89	76.82	87.10	69.58
KDS-Net (ours)	93.69	79.80	88.56	72.42

and

Table 20. Comparison of semantic segmentation accuracies using the proposed method and restoration-based SOTA methods on the KITTI database (unit: %).

Method	PA	mPA	FW IoU	mIoU
DeblurGAN-V2 [34]	84.48	56.53	74.06	48.73
MPRNet [41]	84.56	55.50	73.66	48.33
HINet [42]	85.59	60.70	75.29	52.29
MIMO-Unet [43]	84.12	53.48	72.22	46.00
MIMO-Unet-Plus [43]	84.17	54.64	73.03	47.22
DeepRFT [44]	85.20	59.70	74.60	50.82
DeepRFT-Plus [44]	86.86	62.05	77.19	53.82
Attentive deep [45]	82.87	52.32	71.16	44.70
MHNet [46]	84.02	55.91	72.88	48.03
SDAN-MD [3]	87.27	63.56	77.84	55.59
KDS-Net (ours)	90.10	66.61	82.36	59.29

, our method (KDS-Net) achieves superior segmentation performance across all metrics (PA, mPA, FW IoU, and mIoU) compared to the state-of-the-art motion deblurring methods. This demonstrates the robustness and generalizability of our approach in motion-degraded scenarios.

Furthermore,

Table 21. Comparison of number of parameters, GPU memory, FLOPs of KDS-Net, and restoration-based SOTA methods.

Method	# Parameters (Unit: Mega)	GPU Memory Requirement (Unit: Mega Byte)	FLOPs (Unit: Giga)
DeblurGAN-V2 [34]	44.85	678.81	102.4
MPRNet [41]	59.89	1306.02	1982.4
HINet [42]	128.43	678.81	464.16
MIMO-UNet [43]	46.57	1149.11	205.52
MIMO-UNet-Plus [43]	55.87	2024.62	423.82
DeepRFT [44]	49.31	2009.62	48.82
DeepRFT-Plus [44]	62.73	4176.38	49.70
Attentive deep network [45]	46.67	7497.51	542.73
MHNet [46]	56.79	5276.01	157.34
SDAN-MD [3]	60.09	7719.86	2363.33
Proposed (KDS-Net)	21.44	607.74	112.42

presents a comparison of model complexity, including the number of parameters, GPU memory consumption, and FLOPs. Although KDS-Net does not record the lowest FLOPs among all methods, it shows a clear advantage in efficiency, having the smallest number of parameters and requiring the least GPU memory. These results confirm that our method achieves a favorable trade-off between performance and computational cost, making it suitable for deployment in resource-constrained environments.

6. Conclusions

In this study, we addressed the issue of performance degradation in road scene semantic segmentation caused by motion blur resulting from camera shake or object movement. The proposed KDS-Net is a semantic segmentation model optimized for motion-blurred road scene images, utilizing a knowledge distillation (KD) approach to transfer information from a teacher model to a student model. Additionally, we designed an edge mask generator (EMG) to create edge masks from ground truth segmentation masks, which were used as EESL during the training of KDS-Net.

Based on these methods, KDS-Net extracts features with diverse receptive fields through the semantic context module (SCM) and feature aggregation fusion module (FAFM) in the encoder and passes them to the decoder to produce the segmentation output. Ultimately, KDS-Net outputs the segmentation results without requiring a restoration model during inference. In the section Ablation Studies, ablation studies demonstrated that SCM, FAFM, EMG, KD, and variational quantization (VQ) enhance the semantic segmentation performance of motion-blurred images. Furthermore, comparative experiments using two road scene databases showed that the proposed KDS-Net excelled in extracting detailed features for segmentation lost due to motion blur, outperforming various state-of-the-art (SOTA) models, as confirmed by Grad-CAM comparisons. Additionally, t-tests and Cohen’s d-value experiments indicated that the proposed method achieved significantly higher accuracy compared to the second-best method. In addition, to analyze the shape level consistency of the segmentation results under motion blur, we incorporated FDE to evaluate the complexity and irregularity of class-specific regions, thereby providing a structural measure of segmentation correctness within the proposed KD framework.

Our lightweight KDS-Net minimizes the number of parameters to 21.44 million, demonstrating its ability to operate on embedded systems as edge computing at real-time speed for real-world vehicle applications, as shown in the experiments in Section 5.2. From these experiments, we confirm that KDS-Net can be applied to the edge intelligence-empowered internet of vehicles by removing data privacy concerns and communication overheads caused by transmitting the huge amount of images from the vehicle’s frontal-viewing camera to and receiving the segmentation result from the high-computing cloud using 5G technology.

However, as shown in Figure 13, segmentation errors by the proposed method occur in images due to class imbalance. Therefore, future research will focus on reducing errors in cases of class imbalance by exploring new data augmentation techniques and learning strategies to correct class imbalance. Moreover, we plan to study methods to minimize computational cost while preventing performance degradation as much as possible. We will also address issues of various image degradation in road scene segmentation.