LiteFracNet: An Efficient Feature Interaction Network for Fracture Detection in Medical Images

Abstract

Automated fracture detection remains challenging because fracture regions often exhibit low contrast, blurred boundaries, large scale variations, and substantial morphological diversity. Although deep learning-based detectors show promising performance, they often suffer from limited category coverage and insufficient multi-scale feature representation. To address these issues, we propose LiteFracNet, a lightweight framework for accurate and efficient fracture detection. C3-CFormer enhances feature representation via residual aggregation, gated dynamic modeling, and long-range dependency extraction. C2Mona improves fine-grained fracture perception using multi-scale convolution and feature separation–reconstruction. The OmniKernel Fusion Pyramid Network (OFPN) promotes cross-level feature interaction and multi-scale information propagation, improving detection of subtle fractures. The Fusion-Enhanced Detection Head (FED-Head) employs channel alignment and shared convolutions to unify multi-scale features, reducing redundancy in conventional multi-branch heads. On the HBFMID, LiteFracNet achieves a mAP50 of 93.53% with 2.41 M parameters, 8.1 GFLOPs, a 4.9 MB model size, and 87.1 FPS inference speed. It also achieves a mAP50 of 61.43% on the pediatric GRAZPEDWRI-DX dataset, demonstrating competitive cross-dataset adaptability. These results indicate that LiteFracNet has the potential to efficiently assist computers in detecting fractures.

1. Introduction

Fractures are among the most common clinical injuries and are typically caused by disruptions in bone integrity under external forces. They are often associated with pain, swelling, functional impairment, and, in severe cases, various complications, substantially affecting patients’ quality of life [1]. In recent decades, fractures have become a major global public health concern. According to the World Health Organization (WHO), there were approximately 178 million new fracture cases worldwide in 2019, representing a 33.4% increase compared with 1990, while the number of people living with fracture-related symptoms reached 455 million, an increase of 70.1% [2]. Fracture prevalence and characteristics vary considerably across regions and populations [3]. For instance, osteoporosis affected 19.2% of the Chinese population aged 50 years and older in 2018 [4], while fracture incidence has continued to rise in aging societies such as Japan and Germany [5,6]. Similar upward trends have also been reported in developing countries, partly due to traffic accidents and occupational injuries [7]. These findings highlight the growing global burden of fractures and the urgent need for early and accurate fracture detection.

Traditional automated fracture detection methods mainly rely on handcrafted texture features combined with conventional machine learning models for fracture localization. However, these approaches depend heavily on expert knowledge and manual feature design, which limits their robustness and generalizability in large-scale medical imaging applications, such as X-ray, CT, and MRI. For example, Sharma et al. [8] extracted bone texture features using Histogram of Oriented Gradients (HOG) and employed a Support Vector Machine (SVM) classifier, achieving an F1-score of 92%. Muzakki et al. [9] compared HOG, Local Binary Patterns (LBP), and Scale-Invariant Feature Transform (SIFT) features for X-ray fracture detection using a K-Nearest Neighbors (KNN) classifier and reported an accuracy of 99.03% with the HOG-KNN model. In subsequent work, Muzakki et al. [10] further improved the accuracy to 99.30% by integrating KNN, decision trees, and random forests into an ensemble framework. Despite promising results, these methods rely on separating feature extraction from classification, limiting feature expressiveness, adaptability, and scalability. Efficient end-to-end fracture detection methods that minimize handcrafted features and expert intervention are essential for real-time clinical decision support.

With the rapid development of artificial intelligence, deep learning-based object detection has become mainstream for automated fracture detection, improving accuracy and efficiency. One-stage and two-stage detectors are the two dominant paradigms. One-stage detectors, such as YOLO and its variants [11,12], perform localization and classification in a single forward pass, providing high detection speed and computational efficiency. In contrast, two-stage detectors, such as PCB-Faster-RCNN [13], first generate candidate regions through a Region Proposal Network (RPN) and then perform classification and bounding-box regression. Although two-stage detectors generally achieve stronger localization performance, they usually involve more complex inference pipelines and slower runtime. For example, Qi et al. [14] applied Faster R-CNN with a multi-resolution Feature Pyramid Network (FPN) and a ResNet-50 backbone to fracture detection, achieving a detection accuracy of 71.5% at the cost of substantial computational resources. Jia et al. [15] proposed a sternum fracture detection method based on Cascade R-CNN with an attention mechanism, achieving a mAP of 71% on 1227 X-ray images, but its inference speed was only 10.9 FPS, limiting its efficiency for clinical deployment. In comparison, YOLO-based detectors provide a more favorable trade-off between detection accuracy and computational efficiency through end-to-end prediction. For instance, Qiu et al. [16] incorporated HGNetV2, DySample, GSConv, and Focaler-CIoU into YOLOv4 for wrist fracture detection, achieving a mAP50 of 65% with an inference time of 2.7 ms. Fu et al. [17] developed a YOLOv4-based model for ultrasound fracture fragment detection that outperformed YOLOv3 in mAP50, although the number of detectable categories remained limited.

Despite these advances, current fracture detection models remain insufficient for routine clinical application because most are evaluated on limited datasets and rarely consider complex multi-lesion cases, making their robustness across different anatomical regions, patient populations, imaging modalities, and acquisition conditions uncertain. Moreover, improvements in benchmark accuracy often come with increased computational cost, while clinically important false-negative errors and external validation remain insufficiently assessed. To address this, we propose a lightweight one-stage fracture detection model that enhances performance while maintaining computational efficiency. The main contributions are:

(1) We design C3-CFormer to enhance contextual feature representation by combining lightweight residual aggregation, gated dynamic modeling, and Transformer-based long-range dependency learning.

(2) We introduce C2Mona to capture fine-grained fracture features through multi-scale convolution and feature separation–reconstruction, thereby improving fracture detection.

(3) We introduce the OmniKernel Fusion Pyramid Network to strengthen cross-level feature fusion and multi-scale information propagation while preserving subtle structural details.

(4) We design FED-Head to reduce structural redundancy and computational cost through channel alignment and shared convolutions while maintaining robust multi-scale detection performance.

The rest of this paper is organized as follows: Section 2 reviews fracture detection research; Section 3 introduces the architecture and key modules of LiteFracNet; Section 4 details the experimental setup and dataset; Section 5 presents results and analysis; and Section 6 discusses limitations and future directions.

2. Related Work

2.1. The Application of Deep Learning in Medical Lesion Detection

Object detection is a key computer vision task that localizes and classifies objects in images. Unlike image classification, it also predicts bounding boxes with confidence scores. Recent deep learning advances have improved medical image analysis, particularly lesion detection, enhancing automation and diagnostic precision. Baldini et al. [18] proposed the SRE-YOLO method, which enables automatic detection of laryngeal cancer lesions at different scales from endoscopic White Light (WL) and Narrow-Band Imaging (NBI) images, with an inference speed of 58.8 frames per second (FPS). Similarly, Chen et al. [19] designed the HD-YOLO model by integrating Dual-Domain Fusion Convolution (DDFConv) and Multi-Scale Channel Fusion (MSCF), improving the detection efficiency of endometrial lesions, achieving a mAP of 79.5% and a 13.9% increase in FPS compared to the baseline. Wang et al. [20] designed the SIH-Det model, incorporating the Multi-Scale Dilated Feature Aggregation (MDFA) module and Dynamic Hybrid Processing Unit (DHPU), resulting in a mAP50 of 98.4%. Based on YOLOv7 and HLSAM, Liu et al. [21] proposed a segmentation method for breast cancer microcalcification clusters; by combining the accuracy of YOLOv7 with the segmentation capability of HLSAM, this method achieved a Dice coefficient of 88.76% ± 0.32% on the VinDr-Mammo dataset. Kang et al. [22] presented the PK-YOLO brain tumor detection model, which significantly improves the detection performance for small brain tumors by integrating pre-trained knowledge with lightweight convolutional neural networks. Sun et al. [23] proposed the GD-RTDETR model, which introduces Cascaded Group Attention (CGA), Gated Sampling, and a Dual-Fusion Enhanced Path Aggregation Network (GDPAN), increasing the mAP50 for lung nodule detection by 4.1% compared with the baseline. Finally, Han et al. [24] constructed the lightweight breast cancer detection network YOLOv9-AGMA, in which an Adaptive Gated Multi-scale Attention (AGMA) module improves detection accuracy by 9.9% over the baseline model.

Deep learning technologies have demonstrated considerable potential in medical imaging diagnostics, not only enhancing diagnostic accuracy but also optimizing clinical workflows. With ongoing advances in algorithms, these technologies are poised to play an increasingly pivotal role in aiding diagnosis and quantifying pathological lesions.

2.2. Detection and Classification of Fracture Lesions

Accurate fracture localization remains challenging due to lesion diversity and blurred boundaries. Various improvements to one-stage detectors have been proposed to address this issue. Zou et al. [25] incorporated an attention mechanism into the YOLOv7 model, achieving a mAP of 86.2% on the FracAtlas dataset. However, this approach increased parameter complexity and did not include cross-modal training to validate the model’s generalization performance. Zhang et al. [26] optimized the YOLO11 model by integrating the Bone-Multi-Scale Convolutional Attention (Bone-MSCA) module and Focal-SIoU loss function, improving mAP50 by 1.24% over the baseline, although the accuracy gain was modest. Nguyen et al. [27] evaluated the YOLOv4 model on wrist fracture X-ray datasets, achieving 90.36% accuracy, but the model’s redundant parameters limited its clinical deployment. Liu et al. [28] achieved 92.1% mAP50 using YOLO11 on fracture datasets; however, complex cases involving multiple coexisting lesions were excluded from the analysis. The Kid-YOLO model, proposed by Liu et al. [29] for pediatric wrist fracture detection, improved accuracy by 3.2%, but its limited training and validation datasets posed risks of overfitting, restricting its broader clinical applicability. Ju et al. [30] introduced the Feature Context Excitation-YOLOv8 model, which achieved significant results on the GRAZPEDWRI-DX dataset. However, the minimal variant of this model contains 43 million parameters and consumes 465.6 GFLOPs. Hsieh et al. [31] proposed the YOLOR model, achieving 93.4% accuracy on spinal CT image datasets by replacing the backbone network with MobileViT and EfficientNet_NS. However, the model’s high parameter complexity and the dataset’s limited category diversity remain notable drawbacks.

Therefore, the key research gap lies not only in limited category coverage and model complexity, but also in the insufficient evidence regarding robustness across datasets, patient populations, anatomical regions, and clinically challenging cases. Accordingly, this study aims to enhance fracture feature representation while reducing computational overhead, thereby establishing a technically viable foundation for subsequent external and clinical validation.

3. Research Methodology

3.1. Proposed Method

Figure 1 illustrates the overall workflow of the proposed fracture detection framework. All images were resized to 640 × 640 pixels, with the corresponding annotations adjusted accordingly. The dataset was divided into training, validation, and test sets according to the predefined split. The training set was used for model optimization, while the validation set was used to monitor the training process and select the best-performing model. The selected model was subsequently evaluated on the independent test set. During inference, predictions below the predefined confidence threshold were removed, and the remaining results were presented using bounding boxes and class labels.

3.2. LiteFracNet Model

This paper proposes LiteFracNet, an efficient and lightweight model for multi-class fracture detection. LiteFracNet integrates several key modules. C3-CFormer enhances contextual feature representation through residual aggregation, gated dynamic modeling, and long-range dependency learning. C2Mona captures fine-grained fracture cues via multi-scale convolutions and feature separation–reconstruction, improving the detection of blurred fracture boundaries. OFPN promotes cross-level feature interaction and multi-scale information propagation, thereby preserving subtle fracture details. FED-Head aligns channel dimensions and employs shared convolutions to model multi-scale features in a unified feature space, reducing redundancy and improving cross-scale information flow. The overall architecture of LiteFracNet is shown in Figure 2.

3.3. C3-CFormer Module

Current one-stage fracture detectors primarily rely on multi-scale feature modules to enhance feature extraction. However, because these modules are built on local convolutions, they struggle to capture long-range dependencies between distant features. Although some models incorporate self-attention mechanisms to model long-range dependencies and better exploit distant contextual information, their high computational complexity and memory overhead still hinder real-time deployment.

To address these limitations, we construct C3-CFormer by integrating the existing ConvFormer block [32] and CGLU mechanism [33] into the C3 residual aggregation framework. The novelty lies in this fracture-oriented architectural integration, which combines long-range contextual modeling with local gated feature interaction while maintaining a lightweight structure. Embedded within the C3 framework, this architecture preserves the advantages of lightweight residual aggregation while incorporating Transformer-based long-range dependency modeling and gated dynamic mechanisms, thereby substantially improving feature representation. The structure of C3-CFormer is illustrated in Figure 3.

The ConvFormer module in the C3-CFormer architecture uses a Channel Multi-layer Perceptron (MLP) for information transfer and feature transformation along the channel dimension. Dependence between channels is captured through nonlinear transformations in the fully connected network. However, Channel MLP has limitations, particularly its inability to effectively capture local spatial information, and its structure restricts dynamic adaptability.

To address these issues, this study introduces the Convolutional Gated Linear Unit (CGLU) into ConvFormer, replacing the traditional MLP. This modification enhances both the model’s performance and computational efficiency. The computation process is as follows:

$$X_{middle}=SeparableConv(Norm(X))+{\beta }_1(X)$$

(1)

$$X_{output}=CGLU(Norm(X_{middle}))+{\beta }_2(X_{middle})$$

(2)

where $X\in {ℝ}^{C\times H\times W}$ represents the input features, ${\beta }_1$ and ${\beta }_2$ denote the residual scaling factors. The CGLU enhances local feature modeling by combining convolutional operations with a gating mechanism. Specifically, the Gated Linear Unit (GLU) is a channel-mixing mechanism formed by two linear projections. In the gating branch, the input first undergoes a 3 $\times$ 3 depth-wise convolution to capture local features at each spatial position, and a gating signal is then generated from the neighboring features. This signal is activated using GELU, after which the original input and the gating signal are combined via element-wise multiplication to regulate the information flow. In this way, the model can adaptively modulate the input based on local features, producing more representative outputs.

$$CGLU(X)=Conv(GELU(DWConv(Conv(X_1)))\odot Conv(X_2))$$

(3)

$$Y_{output}=CGLU(X)+X$$

(4)

where $Conv(X_1)$ and $Conv(X_2)$ denote the two channel-wise splits obtained from a $1\times 1$ convolution, ⊙ represents element-wise multiplication, DWConv refers to depth-wise convolution, and GELU is the activation function.

3.4. C2Mona Module

Fracture regions in medical images typically exhibit low contrast, blurred edges, and substantial morphological variability, which poses significant challenges for multi-scale feature extraction. Although the existing Cross-Channel Parallel Spatial Attention (C2PSA) module improves feature representation through multi-layer attention mechanisms, it still has the following limitations: (1) multi-layer attention computations introduce considerable computational overhead and (2) its fixed convolutional kernel structure struggles to capture both local edge details and global texture information.

To address these limitations, we develop C2Mona by integrating the existing Mona transformation block [34] into a partial-feature aggregation architecture based on channel splitting, parallel feature transformation, and subsequent feature recombination. Through the coordinated use of multi-scale depth-wise convolution, channel compression–reconstruction, and residual fusion, C2Mona is tailored to capture low-contrast fracture features with blurred boundaries while maintaining low computational overhead. The architecture of C2Mona is illustrated in Figure 4.

The C2Mona module inherits the “grouping-parallel-fusion” strategy from the C2-series modules. The input feature $X\in {ℝ}^{C\times H\times W}$ is first processed by a convolutional layer and then divided into sub-feature groups along the channel dimension. Each sub-feature group is passed through a Mona sub-module for feature extraction. The resulting feature groups are concatenated along the channel dimension and subsequently fused by another convolutional layer to produce the final output. The overall functional expression is given as follows:

$$Y_{middle}=Conv(X)$$

(5)

$$Split(Y_{middle})=[Y_1,Y_2]$$

(6)

$$U_0=Y_2$$

(7)

$$U_i=M_i(U_{i-1}),\hspace{1em}i=1,\dots ,n$$

(8)

$$Y=Conv(Concat(Y_1,U_n))$$

(9)

where $M_i(\cdot )$ represents the Mona sub-module, $Y_1$ denotes the identity branch, and $Y_2$ denotes the Mona branch. The core of the Mona sub-module consists of feature normalization, down-projection, multi-scale depth-wise convolution, nonlinear activation, up-projection, and residual fusion. The module first applies down-projection to reduce the channel dimension from $C$ to $C/S_1$, alleviating the computational burden for subsequent multi-scale convolutions. Parallel multi-scale depth-wise convolutions (DWConv 3 × 3, 5 × 5, 7 × 7) then extract feature information at different receptive fields. The resulting convolution outputs are fused through point-wise convolutions to align with the semantic distribution across different scales.

The fused features are passed through the GeLU activation function to introduce nonlinearity and then up-projected to restore the channel dimension to its original size $C$, enabling semantic compensation and reconstruction. Finally, the output is fused with the input features via a residual connection, facilitating context enhancement while maintaining stable feature distribution, thus supporting effective deep network training. The computation expression is as follows:

(1) The input features are first subjected to 2D layer normalization (LayerNorm2d) and then scaled using learnable parameters:

$$X^{\prime }=S_1\odot LN(X)+S_2\odot X$$

(10)

where $S_1$ and $S_2$ are learnable parameters, representing element-wise multiplication across channels.

(2) Channel reduction:

$$P=DownProjection(X^{\prime })$$

(11)

(3) Multi-scale depth-wise convolution:

$$D_k=DownCon{v}_{k\times k}(P),\hspace{1em}k\in \{3,5,7\}$$

(12)

(4) The output is fused through averaging and residual connection:

$$U=P+{\displaystyle \frac{1}{3}}{\displaystyle \sum _{k\in \{3,5,7\}}{D}_k}$$

(13)

Followed by a 1 × 1 convolution and residual operation.

$$Z=U+Con{v}_{1\times 1}(U)$$

(14)

(5) Features are nonlinearly transformed using GELU and subsequently projected back to the original channel dimension while preserving the spatial resolution:

$$Z^{\prime }=UpProjection(GELU(Z))$$

(15)

(6) The channel dimension is restored through a 1 × 1 convolution, with the input residual added:

$$Y=X+Con{v}_{1\times 1}(Z^{\prime })$$

(16)

3.5. OFPN Model

For fracture detection tasks, traditional detectors often lose fine-grained structural information during multi-scale feature fusion in the neck stage, particularly when fractures are subtly concealed, which increases the likelihood of missed detections. To address this challenge, we design the OmniKernel Fusion Pyramid Network (OFPN) by reorganizing existing components, including SPDConv [35], OmniKernel [36], and MFM [37], within a unified cross-level feature-pyramid architecture. The novelty of OFPN lies in the redesigned interaction pathway and its coordinated integration with C3-CFormer to enhance multi-scale information propagation and preserve subtle fracture details.

The proposed OFPN employs SPD-Conv in the high-resolution branch in combination with medium-scale semantic enhancement layers. Furthermore, OFPN introduces an OmniKernel-based feature aggregation structure (the OmniKernel fusion module) that performs weighted fusion of features at different scales, thereby enhancing the network’s discriminative power. To further improve feature modeling, the C3-CFormer module from the backbone is integrated into OFPN, enabling the network to better adapt to diverse fracture morphologies. Finally, in the multi-scale feature concatenation stage, the Modulation Fusion Module applies attention-guided adaptive recalibration for efficient feature integration, improving detection accuracy and robustness while maintaining real-time performance.

3.5.1. SPDConv Module

SPDConv is an enhanced convolutional structure designed to improve feature retention in low-resolution images, as illustrated in Figure 5. Unlike conventional downsampling in one-stage detectors, this module replaces strided convolutions and pooling with a Space-to-Depth (SPD) transformation, which mitigates detail loss and preserves fine-grained features. Specifically, SPDConv consists of an SPD transformation layer followed by a stride-1 convolutional layer, enabling efficient feature extraction and thereby improving fine-grained information retention. The SPD layer rearranges the input feature $X\in {ℝ}^{C\times H\times W}$ into multiple sub-feature map slices, mapping spatial resolution into the channel dimension. When the scaling factor is set to 2, the down-sampling operation produces four sub-feature maps:

$$\left\{\begin{array}{c}{G}_{0,0}=X[0:S:scale,0:S:scale];\\ G_{1,0}=X[1:S:scale,0:S:scale];\\ G_{0,1}=X[0:S:scale,1:S:scale];\\ G_{1,1}=X[1:S:scale,1:S:scale],\end{array}\right.$$

(17)

In this process, the input feature map is partitioned into four equally sized sub-feature maps, which are concatenated along the channel dimension to form an intermediate feature map $X^{\prime }\in {ℝ}^{(S/2)\times (S/2)\times 4C_1}$. This operation reduces spatial resolution while enriching the channel-wise feature representation. A convolution with a stride of 1 is then applied to $X^{\prime }$ to obtain $X^{″}$, where the channel dimension is compressed in a pixel-wise manner using learnable parameters, thereby preserving spatial information. This design maintains global contextual information encoded in the channel dimension and alleviates the detail loss typically associated with conventional down-sampling methods.

3.5.2. OmniKernel Fusion Module

The OmniKernel Fusion module adopts multi-level residual architecture. The input feature map is split into two paths: one path is processed by a lightweight convolutional subnetwork, while the other is propagated directly to subsequent layers via a residual connection. The features from both paths are then concatenated along the channel dimension and used as input for the following processing stages, as illustrated in Figure 6.

The OmniKernel module comprises three main branches: a global branch, a large-kernel branch, and a local branch. The global branch captures broad contextual information using a Dual-domain Channel Attention Mechanism (DCAM) and a Frequency-Selective Attention Mechanism (FSAM), enabling the network to learn more comprehensive feature representations. The large-kernel branch employs deep convolutions with large receptive fields to provide multi-granularity context and enrich feature information. The local branch focuses on fine-grained local features through point-wise convolutions, ensuring effective retention of small-scale information.

In the large kernel branch, the input is processed through three independent convolutional operations. Specifically, a 31 × 31 depth-wise convolution captures broad contextual information, while 1 × 31 and 31 × 1 depth-wise separable convolutions extract fine-grained contextual features.

During the inference phase of the global branch, the traditional 31 × 31 convolution kernels fail to cover the global receptive field effectively due to the high resolution of the input images. To address this limitation, we employ a dual-domain processing strategy to enhance global feature modeling. This branch combines the DCAM and FSAM modules to strengthen the model’s global perception by amplifying informative features in both domains. The overall process can be expressed as follows:

(1) The DCAM module applies a Frequency-Channel Attention (FCA) mechanism to the input features, which can be formulated as:

$$X_{FCA}=FFT(X_{Global})\otimes W_{1\times 1}(GAP(X_{Global}))$$

(18)

The FCA output $X_{FCA}$ is processed through a 1 $\times$ 1 convolution and combined with Global Average Pooling (GAP) to globally modulate the features. $⨂$represents element-wise multiplication.

(2) After Fourier transform, the global features are passed into the Spatial Channel Attention (SCA) module to refine feature representation:

$$X_{DCAM}=IFFT(X_{FCA})\otimes W_{1\times 1}(GAP(X_{FCA}))$$

(19)

The output $X_{DCAM}$ of the DCAM module primarily enhances coarse-grained local domain features. This output is then passed into the FSAM to further refine the features along the spatial dimension.

(3) $X_{FSAM}$, the output of the FSAM module, is enhanced using a 1 $\times$ 1 depth-wise convolution to improve local feature representation.

3.5.3. Modulation Fusion Module

One-stage detectors typically concatenate feature maps at different scales along the channel dimension using a Concat operation. However, this approach introduces several issues: (1) Concat merely stacks multi-level features, leading to information redundancy and making it difficult for the model to effectively select informative features; (2) it lacks explicit modeling of relationships between features at different levels; and (3) concatenation increases the number of channels, causing a sharp rise in the computational complexity of subsequent convolutional layers.

To address these issues, we incorporate the Modulation Fusion Module (MFM) into OFPN, as illustrated in Figure 7. The MFM mechanism reduces redundancy by dynamically weighting feature scales, thereby ensuring efficient and relevant feature selection. It also promotes cross-level feature interaction and enhances multi-scale fusion while maintaining computational efficiency.

The attention mechanism in the MFM, consisting of a Multi-Layer Perceptron (MLP) and a Softmax operation, enables the model to automatically adjust the importance of features across different scales, suppress redundant information, and emphasize key features relevant to fracture detection. This process facilitates the effective selection and fusion of multi-scale features. The computation process of the MFM is formulated as follows:

(1) Feature map processing: For the input $in\_feat{s}_i\in {ℝ}^{C_i\times H\times W}$, scale matching is performed using a 1 $\times$ 1 convolution:

$$\begin{array}{cc}{f}_i=Con{v}_i(in\_feat{s}_i),\hspace{1em}& i=1,\dots ,n\end{array}$$

(20)

where $Con{v}_i$ refers to the convolution operation applied to each input feature map.

(2) Concatenation and reshaping: All processed feature maps are concatenated along the channel dimension and reorganized into the shape $(nC,H,W)$:

$$F=Concat(f_1,f_2,\dots ,f_n)$$

(21)

(3) Global feature aggregation: The concatenated feature map undergoes global average pooling, and the output is passed through the MLP module to generate weighted coefficients:

$$attn=Softmax(MLP(AvgPool(F)))$$

(22)

(4) Weighted fusion: The feature maps are weighted and summed using the generated coefficients, resulting in the fused output feature map:

$$out={\displaystyle \sum _{i=1}^{n}att{n}_i}\odot f_i$$

(23)

where $\odot$ represents element-wise multiplication. The final output feature map contains optimized multi-scale fused information.

3.6. FED-Head Model

When the fracture region is partially occluded, the detection heads of mainstream one-stage detectors tend to produce large regression and classification errors. In addition, these detectors typically employ independent detection heads for feature maps at different scales (e.g., P3, P4, P5), which provide limited feature interaction and thus insufficient multi-scale information integration, ultimately constraining overall detection accuracy. To overcome these limitations, we design FED-Head using established operations, including channel alignment, group normalization, shared convolution, and scale-aware regression. Its architectural novelty lies in organizing these operations into a unified lightweight detection head that promotes shared semantic modeling across multiple feature scales while reducing the redundancy of conventional independent prediction branches. Its structure is shown in Figure 8.

Specifically, the feature maps from the P3, P4, and P5 layers are first projected to a unified channel dimension and normalized using 1 × 1 convolution followed by group normalization. A 3 × 3 convolution is then applied to extract shared semantic features, thereby integrating information across different scales within a unified feature space and enhancing the model’s ability to detect small targets. During training, FED-Head adopts both an IoU-based localization loss and a cross-entropy classification loss to ensure accurate regression and robust classification performance, while also improving optimization stability in complex backgrounds. The computation of FED-Head can be formulated as follows:

$$\begin{array}{cc}{\tilde{P}}_i=GN(Con{v}_{1\times 1}^{(i)}(P_i)),& i\in \{3,4,5\}\end{array}$$

(24)

$$\begin{array}{cc}{F}_i=\varphi (GN(Con{v}_{3\times 3}^{shared}({\tilde{P}}_i))),& i\in \{3,4,5\}\end{array}$$

(25)

$$\begin{array}{cc}{\tilde{Y}}_i^{cls}=Con{v}_{1\times 1}^{cls}(F_i),& i\in \{3,4,5\}\end{array}$$

(26)

$$\begin{array}{cc}{\tilde{Y}}_i^{reg}=ConvScal{e}_i[Con{v}_{1\times 1}^{reg}(F_i)],& i\in \{3,4,5\}\end{array}$$

(27)

where $P_i\in {ℝ}^{C_i\times H_i\times W_i}$ represents the input feature of the i-th scale, GN represents Group Normalization, $Con{v}_{3\times 3}^{shared}$ represents the $3\times 3$ convolution with shared weights among the three scales, $\varphi (\cdot )$ represents the nonlinear activation function, $F_i$ represents the shared semantic features sent to the classification and regression branches, ${\tilde{Y}}_i^{cls}$ represents the classification prediction of the i-th scale, and ${\tilde{Y}}_i^{reg}$ represents the bounding box regression prediction.

Additionally, a scale transformation layer (Conv-Scale) is introduced after the regression branch to adaptively rescale and refine the regression outputs at different feature levels. This design alleviates the challenges associated with multi-scale feature processing and ensures stable, reliable detection performance, even for fractures with pronounced scale variations.

4. Experimental Environment and Dataset

4.1. Dataset Construction

The dataset used in this study is the Human Bone Fracture Multimodal Image Dataset (HBFMID) [38], a comprehensive medical imaging dataset designed for fracture detection. HBFMID integrates X-ray and MRI modalities and covers a broad range of human skeletal regions. The dataset consists of 1539 images, including 1347 for training, 128 for validation, and 64 for testing. It contains fractures from various skeletal regions, such as the elbow, fingers, forearm, humerus, shoulder, femur, tibia, hip, and wrist. The performance reported in this study represents aggregate evaluation across the mixed-modality dataset rather than separate modality-specific evaluation.

To further evaluate the model’s generalization ability, we used the GRAZPEDWRI-DX dataset [39] as an additional dataset. The GRAZPEDWRI-DX dataset, released by the Medical University of Graz, contains 20,327 pediatric wrist traumas X-ray images, with 16,233 used for training and 4094 for validation. The dataset includes 74,459 labels and 67,771 labeled objects. Representative sample images (a–d) and the class distributions (e) from both datasets are shown in Figure 9.

4.2. Environmental Settings and Evaluation Criteria

The experiments were conducted on a system running Ubuntu 18.04.6, equipped with an Intel Core i9-9900 CPU (Intel Corporation, Santa Clara, CA, USA) and an NVIDIA GeForce RTX 2080 Ti GPU with 11 GB of memory. The computational environment included CUDA 11.8, Python 3.12.9, and PyTorch 2.4.0 deep learning framework. Hyper-parameter configurations used during training are provided in

Table 1. Experimental environment configuration.

Hyper-Parameters	Value
Epoch	300
Image size	640 × 640
Weight decay	0.0005
Momentum	0.937
Batch size	16
Optimizer	SGD
Seed	0
Pretrained weights	None
NMS IoU threshold	0.5
Lr0	0.01
Lr1	0.01

.

To ensure a fair comparison, the YOLO11 baseline, all ablation variants, and the complete LiteFracNet model were randomly initialized and independently trained from scratch without using any pretrained weights. All models were trained under identical experimental conditions, including the same training, validation, and test splits, input resolution, number of epochs, batch size, optimizer, learning-rate scheduler, weight decay, momentum, data-augmentation strategy, loss configuration, and evaluation criteria. A fixed random seed was used consistently across all comparative and ablation experiments to control the effects of random initialization, data shuffling, and stochastic data augmentation.

Model performance was evaluated using several metrics. Precision (P) measures the proportion of predicted bounding boxes that correctly match the ground truth, while Recall (R) reflects the model’s ability to correctly identify ground-truth bounding boxes. The formulas for Precision and Recall are given as follows:

$$p={\displaystyle \frac{TP}{TP+FP}}$$

(28)

$$R={\displaystyle \frac{TP}{TP+FN}}$$

(29)

The F1-score, calculated as the harmonic mean of Precision and Recall, provides an overall measure of classification performance, and its formula is defined as:

$$F1={\displaystyle \frac{2\times P\times R}{P+R}}$$

(30)

Average Precision (AP) evaluates detection performance by computing the mean precision over a range of recall thresholds. The mean Average Precision (mAP) is obtained by averaging the AP values across all categories and serves as a comprehensive metric of the model’s overall detection capability.

$$AP={\displaystyle {\int }_0^{1}P(R)d(R)}$$

(31)

$$mAP={\displaystyle \frac{{\displaystyle {\sum }_i^{N}A{P}_i}}{N}}$$

(32)

where $N$ denotes the total number of categories in the dataset.

To evaluate the model’s lightweight characteristics, several efficiency metrics, including the number of parameters, GFLOPs, and model size, are considered.

5. Results and Analysis

5.1. Comparative Analysis of Feature Extraction Network Architectures

The feature extraction network of LiteFracNet is composed of the C3-CFormer, SPPF, and C2Mona modules. These modules work synergistically to extract fracture features from different regions and forward them to the neck for multi-scale feature fusion. To validate the effectiveness of this feature extraction network, we conducted comparative experiments in which it was replaced with alternative backbone networks. The results of these comparisons are reported in

Table 2. Comparison results of different feature extraction networks on HBFMID.

Methods	Precision	Recall	F1-Score	Params (M)	GFLOPs	mAP50	Model Size (MB)
LiteFracNet	0.9359	0.8474	0.8895	2.41	8.1	0.9353	4.9
LSKNet [40]	0.9174	0.8295	0.8712	5.39	17.5	0.8746	10.7
StarNet [41]	0.9162	0.8227	0.8669	1.87	5.2	0.8617	4.6
MobileNetv4 [42]	0.9203	0.8397	0.8782	5.19	20.2	0.9242	10.3
UnireplkNet [43]	0.9319	0.8468	0.8873	5.57	14.7	0.9284	11.5
EfficientViT [44]	0.9325	0.8274	0.8768	3.67	8.2	0.9315	7.9

.

Table 2 presents a comparison of different feature extraction networks. Our model outperforms others in both accuracy and efficiency, achieving 93.59% precision, 84.74% recall, and an F1-score of 88.95%. It has 2.41 M parameters, 8.1 GFLOPs, and a model size of 4.9 MB, highlighting its high efficiency. In contrast, while StarNet has fewer parameters, its F1-score is 86.69%, and its mAP50 does not exceed that of our model. LSKNet, MobileNetv4, and UnireplkNet offer good computational efficiency but come with higher model complexities. EfficientViT strikes a balance in computational efficiency, but its mAP50 is still lower than ours. Overall, our model strikes an optimal balance between accuracy and efficiency, making it highly suitable for real-time fracture detection tasks.

5.2. Comparative Analysis of C3-CFormer Architectures

LiteFracNet utilizes four C3-CFormer modules for feature extraction and fusion, effectively combining convolution and attention mechanisms to extract and integrate feature information. To assess the performance benefits of C3-CFormer, we replaced it with other modules and conducted comparison experiments. The results are presented in

Table 3. Comparison results of different C3-CFormer modules on HBFMID.

Methods	Precision	Recall	F1-Score	Params (M)	GFLOPs	mAP50	Model Size (MB)
LiteFracNet	0.9359	0.8474	0.8895	2.41	8.1	0.9353	4.9
AdditiveBlock [45]	0.9266	0.8438	0.8833	2.43	7.4	0.9284	5.2
DeepDBB [46]	0.8875	0.8555	0.8712	2.58	6.3	0.9263	8.7
FasterBlock [47]	0.8903	0.8521	0.8708	2.33	7.1	0.9247	5.0
FMABlock [48]	0.9080	0.8253	0.8641	3.16	8.1	0.8994	6.5
GCConv [49]	0.9303	0.8142	0.8684	2.73	8.9	0.9176	7.3
EBlock [50]	0.9138	0.8344	0.8623	2.42	7.9	0.9165	5.0
ODConv [51]	0.9270	0.8350	0.8786	2.72	7.4	0.9312	5.6
HDRAB [52]	0.9268	0.8105	0.8648	2.76	8.3	0.9133	5.9

.

As shown in Table 3, the C3-CFormer module achieves 93.59% precision, 84.74% recall, and an F1-score of 88.95%. LiteFracNet outperforms the other modules in F1-score, where it surpasses most of the compared models. In terms of computational efficiency, our model has 2.41 M parameters, 8.1 GFLOPs, and a size of 4.9 MB, highlighting its lightweight design. In contrast, FMABlock, DeepDBB, and ODConv have 3.16 M, 2.58 M, and 2.72 M parameters, respectively, resulting in higher computational complexity. While FasterBlock and FMABlock offer advantages in efficiency and model size, their overall performance still falls short compared to our model.

5.3. Comparative Analysis of C2Mona Network Architectures

C2Mona integrates multi-scale depth-wise convolutions with a channel down-projection and up-projection mechanism to enhance cross-scale feature interaction while maintaining computational efficiency. To validate the advantages of C2Mona in feature extraction and information fusion, we replaced C2Mona with other architectural modules and conducted comparative experiments. For a fair comparison, we implemented C2-style variants using the core module of each competing architecture. The results are presented in

Table 4. Comparison results of different C2Mona modules on HBFMID.

Methods	Precision	Recall	F1-Score	Params (M)	GFLOPs	mAP50	Model Size (MB)
LiteFracNet	0.9359	0.8474	0.8895	2.41	8.1	0.9353	4.9
C2PSA [53]	0.9241	0.8359	0.8778	2.35	8.1	0.9262	4.8
C2DA [54]	0.9152	0.8265	0.8686	2.37	8.1	0.9178	4.9
C2BRA [55]	0.9339	0.8378	0.8832	2.99	8.3	0.9295	6.0
C2MSLA [56]	0.9234	0.8469	0.8835	2.96	8.3	0.9346	6.0

.

As shown in Table 4, the C2Mona module achieves the highest detection accuracy while maintaining a high recall rate. Although C2PSA and C2DA have fewer parameters, they exhibit a significant performance degradation. C2BRA achieves high precision; however, it does not outperform C2Mona in terms of overall performance. Compared with the other modules, C2Mona demonstrates superior capability in handling complex tasks while maintaining low computational cost, thereby improving robustness and generalization.

5.4. Comparative Analysis of OmniKernel Fusion Modules

To evaluate the performance of the proposed OmniKernel fusion module in feature fusion and fracture detection under high occlusion conditions, we compared it with several mainstream feature fusion modules. The results, presented in

Table 5. Comparison results of different fusion modules on HBFMID.

Methods	Precision	Recall	F1-Score	Params (M)	GFLOPs	mAP50	Model Size (MB)
LiteFracNet	0.9359	0.8474	0.8895	2.41	8.1	0.9353	4.9
PST [57]	0.9224	0.8376	0.8780	2.35	7.4	0.9214	4.8
RAB [52]	0.9247	0.8406	0.8806	2.35	7.6	0.9279	4.8
RepConvBlock [58]	0.9304	0.8470	0.8867	2.36	7.5	0.9341	4.9

, demonstrate the performance of the module when replaced with alternative approaches. These comparative experiments effectively validate the module’s advantages in multi-scale feature capture, cross-level information fusion, and computational efficiency.

Table 5 presents a comprehensive performance comparison of various competing models. Our proposed OmniKernel fusion module achieves the best performance across precision, recall, and F1-score metrics. In contrast, the competing modules, including the Pyramid Sparse Transformer (PST), Residual Attention Block (RAB), and RepConvBlock, show lower F1-score and mAP50 values, indicating that they are less effective than our module in detecting targets under complex scenarios.

5.5. Comparative Analysis of FED-Head Architectures

To further enhance LiteFracNet’s performance in human fracture detection, we design FED-Head, an efficient detection head. Compared to mainstream one-stage models, FED-Head is lightweight and significantly improves inference speed by optimizing the feature processing workflow. To evaluate the advantages of FED-Head, we compared it with three different detection heads, and the results are presented in

Table 6. Comparison results of different detection heads on HBFMID.

Methods	Precision	Recall	F1-Score	Params (M)	GFLOPs	mAP50	Model Size (MB)
LiteFracNet	0.9359	0.8474	0.8895	2.41	8.1	0.9353	4.9
Efficient Head [59]	0.9270	0.8451	0.8842	2.30	7.6	0.9215	4.7
RSCD [60]	0.9315	0.8436	0.8854	2.59	8.1	0.9334	6.4
LADH [61]	0.9152	0.8327	0.8720	2.27	7.7	0.9157	4.7

. These experiments provide an in-depth analysis of the performance of each detection head in terms of computational efficiency and robustness.

As shown in Table 6, FED-Head demonstrates excellent overall performance, with a precision of 93.59%, recall of 84.74%, and mAP50 of 93.53%. With 2.41 M parameters, 8.1 GFLOPs, and a model size of 4.9 MB, FED-Head achieves a favorable trade-off between high computational efficiency and precision. The RSCD and LADH architecture also achieved lower mAP50 value than FED-Head, reaching 93.34% and 91.57%, respectively. Their precision, recall, and F1-scores were also lower than those of FED-Head.

5.6. Ablation Studies

To rigorously evaluate the individual and joint contributions of the proposed components, we conducted an ablation study. Specifically, this study systematically investigates four key modules: C3-CFormer (Module A), C2Mona (Module B), OFPN (Module C), and FED-Head (Module D). The results of progressive module integration are summarized in

Table 7. Results of the ablation study on HBFMID.

Methods	Precision	Recall	F1-Score	Params (M)	GFLOPs	mAP50	Model Size (MB)
YOLO11	0.9223	0.8389	0.8786	2.58	6.3	0.8988	5.3
+A	0.9293	0.8392	0.8820	2.44	6.2	0.9126	5.0
+B	0.9237	0.8413	0.8806	2.64	6.4	0.9039	5.4
+C	0.9246	0.8469	0.8840	2.66	8.9	0.9237	5.4
+D	0.9187	0.8478	0.8818	2.42	5.6	0.9028	4.9
+A+B	0.9254	0.8423	0.8819	2.49	6.2	0.9255	6.2
+A+B+C	0.9276	0.8438	0.8837	2.57	8.8	0.9286	5.3
+A+B+C+D	0.9359	0.8474	0.8895	2.41	8.1	0.9353	4.9

. The YOLO11 baseline and all ablation variants were randomly initialized and independently trained from scratch without pretrained weights under identical training and evaluation settings.

Table 7 presents the results of an eight-setting ablation study conducted to systematically evaluate the individual and joint contributions of the proposed modules, including C3-CFormer (Module A), C2Mona (Module B), OFPN (Module C), and FED-Head (Module D). Starting from the baseline model, progressively integrating different modules resulted in notable performance variations. When applied individually, Modules A and C yielded more pronounced improvements than Modules B and D. Module C increased mAP50 to 92.37%, indicating its strong capability in enhancing feature representation. The complete model integrating all four modules (LiteFracNet) achieved the best overall performance, reaching a precision of 93.59%, recall of 84.74%, F1-score of 88.95%, and mAP50 of 93.53%, while maintaining moderate computational complexity and a compact model size.

To evaluate the statistical significance of the observed performance difference, YOLO11 and LiteFracNet were independently trained from scratch five times without pretrained weights under identical experimental conditions. The same set of five random seeds was used for both models, yielding five paired mAP50 observations for a two-sided paired t-test.

Table 8. Results of the t-test on HBFMID and GRAZPEDWRI-DX datasets.

Dataset	Methods	Sample Size (n)	Mean ± SD (%)	t Value	df	p Value
HBFMID	YOLO11	5	90.03 ± 0.31	-	-	-
	LiteFracNet	5	93.46 ± 0.34	16.669	4	<0.001
GRAZPEDWRI-DX	YOLO11	5	59.98 ±0.26	-	-	-
	LiteFracNet	5	61.39 ± 0.22	9.257	4	<0.001

presents the t-test results of LiteFracNet on the HBFMID and GRAZPEDWRI-DX datasets.

5.7. Comparison of Different Datasets

5.7.1. Comparison of Different Models on the HBFMID

To comprehensively evaluate the performance of LiteFracNet in human fracture detection, we selected precision, recall, F1-score, and mAP50 as the primary performance metrics. Parameters, GFLOPs, FPS, and model size were used to assess the model’s lightweight characteristics. LiteFracNet was then compared with state-of-the-art (SOTA) models, including YOLOv13, Hyper-YOLO, and RT-DETR, to validate its superior performance. The results are presented in

Table 9. Comparison results of different models on HBFMID.

Methods	Precision	Recall	F1-Score	Params (M)	GFLOPs	mAP50	FPS	Model Size (MB)
YOLOv5n [62]	0.9021	0.8646	0.8830	2.18	5.8	0.9148	102.3	4.7
YOLOv5s [62]	0.9035	0.8647	0.8837	7.82	18.8	0.9246	82.4	16.0
YOLOv6n [63]	0.8973	0.7792	0.8341	4.16	11.5	0.8643	72.4	8.6
YOLOv6s [63]	0.9329	0.8126	0.8686	15.98	42.8	0.8678	65.2	32.2
YOLOv9t [64]	0.8486	0.8479	0.8482	1.73	6.4	0.8552	105.7	4.2
YOLOv9s [64]	0.9247	0.8549	0.8884	6.20	22.1	0.9212	61.2	13.3
YOLOv10n [65]	0.8541	0.7783	0.8144	2.27	6.5	0.8368	88.5	5.8
YOLOv10s [65]	0.8673	0.8472	0.8571	7.22	21.4	0.8476	58.4	16.6
YOLO11n [66]	0.9223	0.8389	0.8786	2.58	6.3	0.8988	100.7	5.3
YOLOv12n [67]	0.9019	0.7941	0.8446	2.51	5.8	0.8582	83.5	5.2
YOLOv13n [68]	0.8420	0.8466	0.8443	2.45	6.1	0.8778	85.2	5.2
Hyper-YOLO [69]	0.9353	0.8453	0.8880	3.62	9.5	0.9342	71.3	7.3
RT-DETR r18 [70]	0.9295	0.8465	0.8861	19.88	57.0	0.9336	42.7	77.0
RTMDet-tiny [71]	0.6926	0.7684	0.7285	4.78	8.2	0.8157	39.2	9.3
RTMDet-s [71]	0.7285	0.8146	0.7691	8.92	14.2	0.8863	35.5	18.2
LiteFracNet	0.9359	0.8474	0.8895	2.41	8.1	0.9353	87.1	4.9

.

As shown in Table 9, LiteFracNet outperforms several mainstream detectors, achieving the highest precision (93.59%), F1-score (88.95%), and mAP50 (93.53%) among the compared models. Compared to high-performance models such as Hyper-YOLO and RT-DETR-r18, LiteFracNet achieves a slightly higher mAP50 while using fewer parameters and a smaller model size. Compared with YOLOv5n, YOLOv6n, and YOLOv10n, LiteFracNet consistently yields better accuracy, with larger gains observed for the lightweight baselines. LiteFracNet achieves efficient real-time inference at a frame rate of 87.1 FPS while maintaining high detection accuracy. Although models such as YOLOv5n, YOLOv9t, and YOLO11n exhibit higher frame rates, LiteFracNet remains capable of performing real-time fracture localization, demonstrating a well-balanced trade-off between accuracy and computational efficiency. Nevertheless, optimizing inference speed continues to be a key focus for future work.

LiteFracNet maintains high precision while demonstrating lightweight architecture. With only 2.41 M parameters, 8.1 GFLOPs, and a model size of 4.9 MB, it is on par with nano-level detectors but offers significantly better precision. In comparison to larger small-scale models like YOLOv6s, YOLOv10s, and RT-DETR, LiteFracNet reduces its parameter count and model size by more than 60%. Overall, LiteFracNet achieves a favorable balance between detection accuracy and computational efficiency, providing a compact architectural foundation for subsequent deployment and optimization on resource-constrained platforms.

To further characterize the computational requirements and deployment potential of LiteFracNet beyond the desktop-GPU benchmark, we conducted a throughput-based theoretical analysis using its computational complexity and parameter count. The reported inference speed of 87.1 FPS was measured on an NVIDIA GeForce RTX 2080 Ti. LiteFracNet requires 8.1 GFLOPs for each 640 × 640 input image. Assuming effective sustained computational throughputs of 0.1, 0.5, and 1.0 TOPS under consistent numerical precision and operation-count conventions, the estimated network-only latencies are approximately 81.0, 16.2, and 8.1 ms, corresponding to 12.3, 61.7, and 123.5 FPS, respectively. Together with its compact architecture of 2.41 million parameters and a 4.9 MB saved model weight file, these estimates demonstrate the favorable computational and storage characteristics of LiteFracNet and provide quantitative support for its deployment potential on low-power platforms. This analysis provides an architecture-level efficiency reference under controlled throughput assumptions, while its interpretation should account for platform-dependent factors, including activation-memory consumption, image preprocessing and post-processing, data-transfer latency, runtime implementation efficiency, memory-bandwidth constraints, power consumption, and thermal behavior. Furthermore, the reported 4.9 MB represents the on-disk size of the saved model weight file rather than the peak memory consumption during inference. Therefore, this analysis provides a quantitative basis for subsequent platform-specific deployment and optimization, while evaluation on representative low-power hardware will be needed to quantify the actual end-to-end latency, runtime memory consumption, and energy efficiency.

5.7.2. Comparison of Different Models on the GRAZPEDWRI-DX Dataset

To further evaluate the model’s cross-domain generalization ability, LiteFracNet was independently tested on the GRAZPEDWRI-DX dataset. The dataset contains pediatric wrist-trauma radiographs with multiple annotated findings and fracture-related labels. The comparison results are shown in

Table 10. Comparison results of different models on GRAZPEDWRI-DX dataset.

Methods	Precision	Recall	F1-Score	Params (M)	GFLOPs	mAP50	Model Size (MB)
YOLOv5n [62]	0.6729	0.5682	0.6161	2.18	5.8	0.5897	4.7
YOLOv6n [63]	0.6411	0.5525	0.5935	4.16	11.5	0.5751	8.6
YOLOv9t [64]	0.6246	0.5825	0.6028	1.73	6.4	0.5742	4.2
YOLOv10n [65]	0.6523	0.5922	0.6207	2.27	6.5	0.5894	5.8
YOLO11n [66]	0.6957	0.5926	0.6400	2.58	6.3	0.6009	5.3
YOLOv12n [67]	0.6421	0.5881	0.6139	2.51	5.8	0.5871	5.2
YOLOv13n [68]	0.6934	0.5745	0.6284	2.45	6.1	0.6042	5.2
Hyper-YOLO [69]	0.5941	0.6006	0.5973	3.62	9.5	0.5998	7.3
LiteFracNet	0.6551	0.6345	0.6446	2.41	8.1	0.6143	4.9

.

Despite differences in model parameter scale and computational complexity, LiteFracNet outperforms other models across several key metrics. Specifically, LiteFracNet achieves 65.51% precision, 63.45% recall, and 64.46% F1-score, demonstrating balanced performance among lightweight models. Compared to one-stage detectors of similar scale, LiteFracNet shows significant improvements in F1-score and mAP50, underscoring its superior feature extraction and target localization capabilities.

Although LiteFracNet achieved the highest mAP50 of 61.43%, its improvement over the strongest baseline models was relatively limited. Specifically, the mAP50 exceeded those of YOLOv13 and YOLO11n by 1.00 and 1.34 percentage points, respectively. Therefore, this result should be interpreted as evidence of partial cross-domain adaptability rather than complete domain invariance. The performance degradation relative to HBFMID indicates that differences in patient population, anatomical characteristics, imaging protocols, and annotation distributions remain important challenges.

5.8. Visual Analysis

The confusion matrix is a widely used evaluation tool in multi-class tasks, enabling visualization of the model’s classification results and error distribution across categories. By comparing predicted results with ground truth labels, it quantifies both correct and incorrect classifications for each category. Figure 10 shows the normalized confusion matrix of the LiteFracNet model on the HBFMID, compared with several SOTA models. As depicted in the figure, LiteFracNet outperforms YOLO11, YOLOv12, and YOLOv13, demonstrating higher classification accuracy across all fracture categories and highlighting its superior generalization capability.

To better understand the mechanisms underlying the internal representation of LiteFracNet, we applied feature map visualization techniques to analyze the four C3-CFormer modules and the C2Mona module in the feature extraction network (see Figure 11). Layered visualizations clearly show the evolution of features: the first two C3-CFormer modules (shallow layers) primarily extract low-level features, such as local edges and intensity gradients, while the latter two (deep layers) capture global features, integrating these basic features into high-level semantic information that encodes fracture characteristics with diagnostic value. The C2Mona module enhances the model’s expressiveness and optimizes feature map computation by passing and reusing information across multiple convolution layers.

To further explore the model’s spatial attention distribution, we used Gradient-weighted Class Activation Mapping (Grad-CAM) [72] visualization to compare LiteFracNet with three mainstream detectors across two datasets (see Figure 12). The analysis revealed significant qualitative differences: one-stage detectors exhibited diffuse activation patterns, primarily focusing on background and non-pathological areas, indicating insufficient attention to lesion regions. In contrast, LiteFracNet generated highly concentrated activation heat-maps, with peak responses precisely aligned with lesion boundaries, demonstrating the model’s ability to learn spatially specific, discriminative pathological features.

Figure 13 presents a qualitative comparison of LiteFracNet with mainstream detectors across the two datasets. In the representative cases, LiteFracNet achieved more precise fracture localization and consistently higher prediction confidence, whereas several competing detectors exhibited false-positive responses. When considered together with the Grad-CAM visualizations, these observations indicate that LiteFracNet can more effectively focus on fracture-relevant regions and maintain stable detection behavior under heterogeneous imaging conditions. These qualitative findings provide supportive evidence for the robustness and potential clinical reliability of LiteFracNet.

The receptive field size directly affects the model’s ability to extract features across different scales and complex backgrounds. A larger receptive field captures broader contextual information and improves the modeling of long-range dependencies. Figure 14 compares the effective receptive field distribution of LiteFracNet with three mainstream detectors across two datasets. The results show that LiteFracNet outperforms the other models in receptive field coverage, enabling better integration of spatial context and more effective capture of global features at the fracture site. This gives LiteFracNet a significant advantage in fracture recognition and localization accuracy. In contrast, one-stage detectors have smaller receptive fields, limiting their ability to capture global features, especially in complex backgrounds and for small objects.

6. Discussion

Although LiteFracNet achieved competitive performance on GRAZPEDWRI-DX, its mAP50 was 61.43%, compared with 93.53% on HBFMID, and its improvements over several strong baselines were relatively modest. This numerical difference arises because the two datasets have significant variations in terms of the patient population, anatomical coverage, imaging methods, category definitions, and annotation features. HBFMID includes multiple skeletal regions and both X-ray and MRI images, whereas GRAZPEDWRI-DX consists exclusively of pediatric wrist radiographs. These results suggest that LiteFracNet remains effective in a distinct dataset setting, although its performance is dataset dependent.

Pediatric radiographs present distinct diagnostic challenges. Growth plates, ossification centers, and incomplete ossification may resemble fracture lines and increase false-positive predictions, whereas subtle buckle, incomplete, and nondisplaced fractures may lead to false-negative detections because of their low contrast and limited structural discontinuity. The reported Precision, Recall, F1-score, and mAP50 provide quantitative measures of overall performance, while the Grad-CAM visualizations and representative detection examples offer complementary qualitative evidence of model attention and detection behavior. However, dedicated error stratification across fracture subtypes and patient groups, together with confidence-interval estimation, would provide a more comprehensive assessment of robustness and clinical reliability.

From a clinical perspective, domain-dependent false-positive predictions may increase radiologists’ review burden, whereas false-negative predictions may delay the recognition of subtle fractures. Therefore, further multi-center external validation, population-specific error analysis, and confidence-threshold calibration are required before practical clinical application. Future work will investigate domain adaptation strategies, including feature-distribution alignment, population-aware augmentation, and consistency regularization, to improve performance across heterogeneous patient populations and imaging environments.

Future work could also integrate LiteFracNet with text classification models for radiology reports or clinical notes. LiteFracNet could provide image-based fracture evidence, while the text branch could classify diagnostic findings and urgency and identify fracture-related information, potentially supporting clinical decision-making, report verification, and automated triage. Transformer-based and graph neural network-based text classification studies provide relevant cross-domain methodological references [73,74].

7. Conclusions

In this study, we proposed LiteFracNet, a lightweight fracture detection framework that integrates C3-CFormer, C2Mona, OFPN, and FED-Head to enhance contextual representation, multi-scale feature fusion, and prediction efficiency. LiteFracNet achieved a mAP50 of 93.53% on HBFMID, with only 2.41 million parameters, 8.1 GFLOPs, and a model size of 4.9 MB. On the pediatric GRAZPEDWRI-DX dataset, it achieved a mAP50 of 61.43%, demonstrating competitive performance under a substantially different data distribution. Nevertheless, the performance gap between the two datasets highlights the need for further improvements in cross-domain robustness.

Future work will focus on enhancing computational efficiency and domain adaptability through deployment-oriented optimization and domain-adaptation techniques. Validation on larger, multi-center datasets with more diverse demographic, anatomical, and imaging characteristics will further clarify the clinical applicability and deployment potential of LiteFracNet.