A Lightweight Multi-Scale Feature Fusion Signal Detection Model for Metro Computer Interlocking Systems

Featured Application

The proposed framework enables real-time signal state detection on resource-constrained embedded dispatching terminals of metro computer interlocking systems, improving both the efficiency and safety of rail transit operations.

Abstract

Metro Computer Interlocking Systems are crucial for ensuring the safe and efficient operation of rail transit. However, existing vision-based signal detection methods face challenges including small target sizes, high target density, low image resolution, and the need for deployment on resource-constrained devices. To address these issues, this paper proposes a two-stage lightweight signal detection framework for Metro Computer Interlocking Systems. First, based on YOLOv8, a small object detection layer together with feature fusion modules is introduced to form the YOLOv8-SFF architecture. A Scale Sequence Feature Fusion (SSFF) module is added to adjust the resolution of feature maps and retain critical fine-grained information, enhancing the detection of small visual signals. A Triple Feature Encoding (TFE) module is designed to enhance the recognition of dense small signals while replacing some traditional feature concatenation and upsampling operations, yielding a more compact network. Second, to enable practical deployment, a joint optimization strategy combining Layer-Adaptive Magnitude-based Pruning (LAMP) and Channel-wise Knowledge Distillation (CWD) is applied, in which the unpruned YOLOv8-SFF serves as the teacher and the pruned model serves as the student. In addition, an automatic annotation subsystem based on digital image processing is developed, leveraging color and morphological features to generate high-quality labels. Experimental results show that YOLOv8-SFF achieves a mean average precision (mAP@50) of 98.7%, improving mAP@50 by 11.3 percentage points and recall by 22.1 percentage points over the original YOLOv8. After joint pruning and distillation, the final compact model retains 98.0% mAP while reducing the parameter count by 86.2% and the model size to 1.1 MB, making it well suited for real-time deployment in resource-constrained metro dispatching systems.

1. Introduction

1.1. Railway Interlocking System

The Metro Computer Interlocking System [1] is a computer-based railway signal control system, mainly used to control the operation of signals, turnouts and other railway equipment. Through logical decision-making, the system effectively coordinates various types of equipment to ensure safe train scheduling and operation, preventing safety hazards caused by equipment malfunctions. As a crucial component of railway operation control, the Metro Computer Interlocking System plays a vital role in ensuring the safety of train and shunting operations within stations.

A manual operation physical metro computer interlocking occupancy panel is shown in Figure 1. Currently, computer interlock testing is still dominated by manual inspection, and dispatchers need to analyze and judge the status of signals on the occupancy board to make decisions about the planning and regulation of the metro section. With the increasing complexity of railway station structures, the interlocking testing workload has increased and manual operation not only consumes human resources, but also carries significant risks of subjective judgment and human error.

1.2. AI-Based Detection Approaches

Recent advances in artificial intelligence offer a route to automating this inspection workload. The use of digital image processing and deep learning algorithms [2] to directly detect and analyze the state of computer interlocking signals can significantly improve signal processing efficiency and reduce labor cost. In addition, fault diagnosis functions based on real-time signal status analysis help to discover potential faults in a timely manner [3], further improving the safety of rail transportation. The detection and analysis of signal status also generate a large amount of historical data to provide support to management and decision-makers, and thus provide a scientific basis for the planning and management of the railway system.

Object detection techniques for traffic scenes can be grouped into two broad families: classical pipelines built on hand-crafted features, and modern detectors built on deep neural networks. The classical family locates targets by capturing low-level cues such as object contours, edges, and colour signatures; traffic-sign recognition, for instance, has been tackled by colour-matching in the HSV or HSI colour spaces [4] and by combining Histogram of Oriented Gradients (HOG) descriptors with Scale-Invariant Feature Transform (SIFT) keypoints [5]. Such pipelines remain serviceable in visually clean settings, but their reliance on hand-tuned features limits their ability to localise small signs embedded in cluttered backgrounds.

Deep-learning detectors have since taken over the field; learned end-to-end representations are far more expressive than any hand-crafted descriptor and now dominate most public benchmarks. The most-cited architectures span the Region-Based Convolutional Neural Network (R-CNN) family [6], the YOLO series of one-stage detectors [7], and the Single Shot MultiBox Detector (SSD) [8], each of which has reported strong detection results across a wide range of tasks [9]. The YOLO series has undergone several iterations, each improving on its predecessor. YOLOv3 [10] enhances small object detection through multi-scale prediction. YOLOv5 [11] further optimizes the CSPNet structure introduced in YOLOv4 [12], reducing computational complexity and parameter count while maintaining high detection accuracy. YOLOv8 [13] introduces more efficient detection heads and updated loss functions, resulting in improved speed and precision in diverse application scenarios.

As shown in Figure 2, the display interface of the Metro Computer Interlocking System illustrates the challenges faced by deep learning algorithms in this domain. First, the small size and the large number of signal targets increase the probability of missed or false detections. Second, the low resolution of sample images and the blurring of signal boundaries complicate detection. Third, high-accuracy detection models are often too large to be deployed on the resource-constrained embedded dispatching terminals typically used in practice.

1.3. Research Objectives and Contributions

To address these challenges, this paper proposes a two-stage lightweight signal detection framework for Metro Computer Interlocking Systems. In the first stage, a detection architecture called YOLOv8-SFF is constructed by extending YOLOv8 with a small object detection layer and multi-scale feature fusion modules. In the second stage, the trained YOLOv8-SFF is further compressed by a joint pruning-and-distillation pipeline that combines Layer-Adaptive Magnitude-based Pruning (LAMP) [14] and Channel-Wide Knowledge Distillation (CWD) [15], producing a compact model suitable for deployment on embedded dispatching terminals.

The overarching objective of this work is to provide a signal detection framework for Metro Computer Interlocking Systems that is both end-to-end and deployment-ready, simultaneously addressing (i) small-object recognition, (ii) parameter and inference-time efficiency under embedded constraints, and (iii) the scalability of dataset construction. The main contributions of this paper, each addressing one of these aims, are summarized as follows:

• A detection architecture for small targets at multiple scales, YOLOv8-SFF, is proposed by integrating a P2 detection layer, SSFF modules, and TFE modules [16] on top of YOLOv8. Redundant concatenation and upsampling operations are replaced by TFE blocks, yielding both higher accuracy and a more compact network.
• A joint lightweighting strategy combining LAMP pruning and CWD knowledge distillation is applied to YOLOv8-SFF. Using the unpruned model as the teacher and the pruned model as the student, the resulting compact model retains detection accuracy while achieving an 86.2% parameter reduction, making deployment on embedded dispatching terminals feasible.
• An automatic annotation subsystem based on HSV color analysis, morphological processing, and positional reasoning is developed, which substantially reduces the manual labeling effort required for small and densely distributed interlocking signals.
• Extensive experiments on a real metro interlocking dataset demonstrate that the proposed framework provides an end-to-end solution that balances precision, speed, and deployability for practical rail transit scenarios.

2. Related Works

Deep-learning-based object detection has made significant advances in transportation applications, particularly for traffic signs, pedestrians, and vehicles. Recent studies have explored diverse approaches to improve performance under specific challenges such as precision, efficiency, and robustness.

2.1. Object Detection in Transportation

Yuan et al. [17] combined deep learning with a genetic algorithm to optimize the generation of test sequences for the verification of the signaling system, and Yan [18] proposed an automated testing framework for interlocking systems based on a timed automata model and the firefly algorithm. These studies highlight the growing role of intelligent algorithms in testing and verifying critical transportation systems.

For traffic sign detection, Han et al. [19] improved Faster R-CNN with a revised VGG16 backbone for small traffic signs. Choodowicz et al. [20] combined YOLO with classical image processing techniques to recognize the states of railway signals. Dewi et al. [21] used GANs to generate synthetic data to improve YOLOv4, while Zhang et al. [22] improved YOLOv5 with the Flip-Mosaic algorithm for small targets occluded. For pedestrian detection, Yang et al. [23] optimized SSD for metro station environments, and Lin et al. [24] proposed the DETR-based PED model for crowded scenes.

A particularly relevant sub-family is small-object detection (COCO convention: bounding-box area below $32\times 32$ pixels), the regime in which our task falls. Existing approaches fall into four complementary families: (i) higher-resolution detection heads such as the P2 stride-4 layer; (ii) feature-pyramid refinements (FPN, PANet, BiFPN); (iii) attention-based mechanisms; and (iv) explicit multi-scale fusion modules. Kang et al. [16] combined family (iv) with a P2-like high-resolution head in ASF-YOLO via Scale Sequence Feature Fusion (SSFF) and Triple Feature Encoding (TFE) for cell instance segmentation; we adapt these to the interlocking-signal domain, combining SSFF and TFE with an explicit P2 head to form the SFF design used throughout this work, with per-component contributions quantified in Section 6.3.

2.2. Model Compression for Object Detection

Deep detection models generally yield higher accuracy at the cost of parameter redundancy and computational overhead. Two mainstream compression directions address this.

Network pruning removes unimportant weights or channels. Han et al. [25] proposed a classic three-step pipeline of training, pruning, and fine-tuning. Liu et al. [26] introduced Network Slimming, which applies ${\ell }_1$ regularization on batch-normalization scaling factors for channel-level pruning, while Li et al. [27] directly removed filters with small ${\ell }_1$ norms. Lee et al. [14] proposed Layer-Adaptive Magnitude-based Pruning (LAMP), which normalizes each weight’s importance within its layer and enables global pruning without manual per-layer sparsity tuning.

Knowledge distillation transfers the behavior of a large teacher network to a smaller student. Hinton et al. [28] first formulated the idea using temperature-scaled soft targets. Subsequent work extended the distillation to intermediate features and detection-specific settings. Shu et al. [15] proposed Channel-wise Knowledge Distillation (CWD), which aligns teacher–student activation distributions per channel using KL divergence and performs particularly well on dense prediction tasks.

2.3. Signal Detection in Interlocking Systems

For interlock signal recognition, traditional methods often rely on OpenCV-based pipelines [29,30], which extract colour and morphology cues but are sensitive to interface layout and perform poorly at low resolution. YOLO-based approaches [31] have improved accuracy by adding auxiliary detection heads, but their performance still degrades when equipment names or interface layouts change, and the deployment on embedded terminals remains problematic due to model size. Three properties of metro on-board footage compound the challenge—small, densely co-located targets; an operational zero-confusion requirement on safety-critical command states (motivating the per-class confusion-matrix analysis in Section 6.4); and a tight embedded-deployment budget. The proposed SFF design addresses these three properties through three complementary mechanisms: multi-scale feature fusion via the SSFF and TFE modules, a P2 stride-4 detection head for the smallest targets, and a joint LAMP pruning plus CWD distillation pipeline for the embedded compute budget.

Building on these observations, this paper proposes a lightweight detection framework tailored for Metro Computer Interlocking Systems, combining architectural improvements for small-object detection with a joint pruning-and-distillation pipeline that addresses the deployment bottleneck.

3. Proposed YOLOv8-SFF Architecture

The general network architecture of YOLOv8-SFF is shown in Figure 3. Based on YOLOv8, the model incorporates a Small Object Detection Layer (denoted P2), allowing more efficient detection of small signal targets and more accurate localization.

The proposed model integrates the output of the P2 detection layer with the neck output of P3 and P4 through an SSFF module. The addition of the P2 detection layer further enhances small-target detection, reduces missed detections, and improves recall. The SSFF module preserves detection details and strengthens the network’s ability to detect small targets. In addition, the outputs of P2–P4 and P3–P5 from the backbone are fed into two TFE modules for cross-scale feature fusion, capturing detailed information from small targets and enhancing the detection of dense small signals. The TFE modules also replace certain feature concatenation and upsampling operations, retaining only one upsampling operation, which reduces both the parameter count and computational complexity.

Architecture summary. At the deployment scale (YOLOv8n, width factor $0.25$, input $640\times 640$), the four detection heads receive feature maps with the following spatial resolution and channel dimension. The newly-added P2 head operates at stride 4 on a $160\times 160$ map with 32 channels and is responsible for the smallest targets (the principal contribution of this work). The P3 head at stride 8 ($80\times 80$, 64 channels) covers small-to-medium targets, the P4 head at stride 16 ($40\times 40$, 128 channels) covers medium targets, and the P5 head at stride 32 ($20\times 20$, 128 channels) covers large targets and global context. The two SSFF blocks fuse three pyramid-level feature maps each—$\{p_3,p_4,p_5\}$ for the deep SSFF and $\{p_2,p_{3\text{-fused}},p_{4\text{-fused}}\}$ for the shallow SSFF, both aligned to the highest-resolution input among their three inputs—and the two TFE blocks operate at the P3 ($80\times 80$) and P4 ($40\times 40$) levels, each replacing a conventional concatenation-plus-upsampling stage of the original YOLOv8 neck. The total deployed model has $2.49$ M parameters and $12.0$ GFLOPs.

3.1. Small Object Detection Layer

The YOLOv8 network comprises three main components: the backbone, the neck, and the head. Since small objects typically only occupy a few pixels, they are prone to being overlooked or misclassified. To mitigate this, a Small Object Detection Layer is incorporated into YOLOv8, as illustrated in Figure 4, where P2 denotes this layer.

In the backbone, CSPDarknet-53 generates five feature maps of different scales (P1–P5) through consecutive downsampling operations. The neck uses a Feature Pyramid Network (FPN) for feature fusion, allowing information exchange between different scales via upsampling (U2–U5) and downsampling (D2–D5). This produces four bounding-box predictions (P2–P5 boxes) in the head, allowing the network to effectively handle multi-scale detection.

3.2. SSFF Module

The SSFF module (Figure 5) resizes three feature maps of different scales to a uniform size and stacks them as input for 3D convolution, facilitating multi-scale feature fusion. The feature maps at varying scales undergo convolution with Gaussian kernels of progressively larger standard deviation, as defined in Equations (1) and (2):

$$G_{\sigma }(x,y)={\displaystyle \frac{1}{2\pi {\sigma }^2}}{e}^{-{\displaystyle \frac{x^2+y^2}{2{\sigma }^2}}}$$

(1)

$$F_{\sigma }(i,j)=\sum _u\sum _{v}f(i-u,j-v)\times G_{\sigma }(u,v)$$

(2)

In the above equations, $G_{\sigma }$ denotes a 2D Gaussian kernel parametrised by standard deviation $\sigma$; $f(i,j)$ stands for the 2D input feature map, while u and v index the kernel offsets. The output map $F_{\sigma }$ is produced by convolving the input feature map with a sequence of such Gaussian kernels whose standard deviations grow monotonically, yielding a stack of multi-scale responses. These responses are then assembled along an auxiliary axis into a 3D tensor, from which scale-sequential representations are extracted by a 3D convolution. To address the varying resolutions of the Gaussian-smoothed maps and to retain critical details for small-target detection, nearest-neighbor interpolation aligns all feature maps with the highest resolution. In the overall network, the small target detection layer from the backbone is fused with the P3 and P4 feature layers from the neck through the SSFF module, enhancing the model’s ability to detect small targets.

3.3. TFE Module and Structural Optimization

To handle dense signal regions, the TFE module (Figure 6) partitions the incoming features into three scales—large, medium and small—and merges them so that finer details survive the downstream pipeline. Prior to encoding, the channel count of each branch is realigned to match the medium-scale (primary) feature. The large branch (Large) first passes through a convolution that reduces its channel dimension to $1C$, lowering the cost of the later concatenation; the resulting tensor is then downsampled by a hybrid block that combines max and average pooling, which improves translation invariance and robustness to small spatial perturbations. On the small-scale branch (Small), the channel count is similarly realigned and the feature map is upsampled by nearest-neighbour interpolation, a choice that preserves local detail and avoids losing information about small objects. After this preprocessing, the large-, medium- and small-scale branches share an identical spatial resolution and are concatenated along the channel dimension:

$$F_{TFE}=\mathrm{Concat}(F_l,F_m,F_s)$$

(3)

$F_{TFE}$ above denotes the TFE module’s output, while $F_l$, $F_m$ and $F_s$ refer respectively to the large-, medium- and small-scale feature maps. By construction, $F_{TFE}$ inherits the spatial resolution of $F_m$ but carries three times its channel count. The TFE module improves the detection of dense small targets by adjusting channel numbers, applying hybrid pooling, and fusing multi-scale features. In the overall architecture, using two TFE modules in place of certain concatenation and upsampling operations, while retaining only one upsampling step, optimizes the network structure and substantially reduces the parameter count.

3.4. Loss Function

The plain IoU loss used in anchor-based detectors captures neither the displacement nor the geometric overlap between predicted and ground-truth boxes adequately. A series of IoU variants have been proposed to remedy this: GIoU [32] and the joint DIoU/CIoU formulation [33] progressively incorporate centroid distance and aspect-ratio penalties, with CIoU (a DIoU extension that adds an aspect-ratio factor) being adopted in YOLOv5 and YOLOv8. EIoU [34] pushes this line further by explicitly penalising the width and height discrepancies between predicted and ground-truth boxes, which sharpens localisation on small objects. We therefore use EIoU in the detection head. The EIoU loss decomposes into three additive terms—an IoU term $L_{IoU}$, a distance term $L_{dis}$, and an aspect term $L_{asp}$:

$$\begin{array}{cc}\hfill L_{EIoU}& =L_{IoU}+L_{dis}+L_{asp}\hfill \\ \hfill & =1-IoU+{\displaystyle \frac{{\rho }^2(b,b^{gt})}{w_c^2+h_c^2}}+{\displaystyle \frac{{\rho }^2(w,w^{gt})}{w_c^2}}+{\displaystyle \frac{{\rho }^2(h,h^{gt})}{h_c^2}},\hfill \end{array}$$

(4)

In the equation above, $\rho (·)=\parallel b-b^{gt}{\parallel }_2$ stands for the Euclidean distance; b and $b^{gt}$ are the centre coordinates of the predicted box B and the ground-truth box $B^{gt}$ respectively; $w^{gt}$ and $h^{gt}$ are the side lengths of the ground-truth box; and $w_c$, $h_c$ are the side lengths of the minimum enclosing rectangle that contains both boxes. Relative to CIoU, EIoU converges faster and yields more accurate bounding-box regression.

4. Model Compression via Joint Pruning and Distillation

4.1. Motivation for Lightweighting

Although YOLOv8-SFF achieves high accuracy, its 2.49 M parameters and 5.1 MB footprint can still be prohibitive for the embedded dispatch terminals used in practice, where memory and compute are tightly constrained. To bridge this gap, we propose a two-stage compression pipeline that first prunes the trained YOLOv8-SFF using LAMP and then recovers accuracy via CWD knowledge distillation.

4.2. LAMP-Based Pruning

LAMP [14] evaluates the importance of each weight through a layer-adaptive score. For a flattened weight tensor W with indices sorted in ascending order of magnitude, the LAMP score for index u is defined as

$$\mathrm{score}(u;W)={\displaystyle \frac{{\left(W\left[u\right]\right)}^2}{{\sum }_{v\ge u}{\left(W\left[v\right]\right)}^2}}.$$

(5)

Weights with the smallest LAMP scores across the whole network are pruned globally until a target sparsity is reached. Unlike uniform pruning, LAMP automatically allocates sparsity across layers based on their internal weight distributions, avoiding manual per-layer tuning. We control the compression strength via a Speedup factor defined as the ratio of pre-pruning to post-pruning GFLOPs:

$$\mathrm{Speedup}={\displaystyle \frac{{\mathrm{GFLOPs}}_{\mathrm{pre}}}{{\mathrm{GFLOPs}}_{\mathrm{post}}}},\mathrm{PruningRate}={\displaystyle \frac{{\mathrm{GFLOPs}}_{\mathrm{pre}}-{\mathrm{GFLOPs}}_{\mathrm{post}}}{{\mathrm{GFLOPs}}_{\mathrm{pre}}}}.$$

(6)

Larger Speedup values correspond to more aggressive pruning, leading into the distillation-based recovery stage described next.

4.3. Channel-Wise Knowledge Distillation

Aggressive pruning inevitably degrades accuracy. To recover performance, we apply CWD [15] using the original unpruned YOLOv8-SFF as the teacher T and the pruned model as the student S. For each channel c, the activation maps are converted into spatial probability distributions through a softmax with temperature $\tau$:

$$\varphi \left(y_{c,i}\right)={\displaystyle \frac{exp(y_{c,i}/\tau )}{{\sum }_{j}exp(y_{c,j}/\tau )}}.$$

(7)

The distillation loss is the KL divergence between teacher and student distributions, summed over channels:

$${\mathcal{L}}_{\mathrm{CWD}}={\displaystyle \frac{{\tau }^2}{C}}\sum _c\sum _i\varphi \left(y_{c,i}^T\right)log\left({\displaystyle \frac{\varphi \left(y_{c,i}^T\right)}{\varphi \left(y_{c,i}^S\right)}}\right).$$

(8)

Per-channel alignment encourages the student to mimic the teacher’s spatial attention patterns on foreground regions, which is particularly beneficial for dense small-signal detection.

4.4. Joint Optimization Pipeline

The overall procedure consists of four steps: (1) train YOLOv8-SFF on the interlocking signal dataset to obtain the teacher; (2) apply LAMP pruning at a target Speedup to the trained YOLOv8-SFF to obtain a compact student with the same macro-architecture; (3) distill the pruned student using the CWD loss in Equation (8), with the unpruned YOLOv8-SFF as the frozen teacher and without any further architectural modification; (4) deploy the distilled compact model on the target embedded terminal. Compared to the conventional prune-then-finetune paradigm, replacing fine-tuning with CWD distillation produces faster accuracy recovery and better final performance, especially at high pruning ratios, as empirically verified in Section 6.6.

5. Signal Dataset and Annotation System

5.1. Signal Classification

As shown in

Table 1. Signal classification and its legend.

Signal Type	Display Legend	Classification Name	Function Description
Shunting Signal		RL	Prohibit shunting
		BL	Suspend shunting
Entry/Exit Signal		BLFS	Blocking
		RDL	Prohibit inbound
		DRL	Outbound prohibited
Turnouts		SG	Positioning
		SY	Reverse Positioning
Track Lines		LB	Idle
		LR	Occupied
		LSB	Incoming

, the signals in the upper computer interface of the Metro Computer Interlocking System are categorized into shunting/entry-exit signaling machines, turnouts, and track lines. Due to the limited duration of certain signal states in the original video, fewer samples were available for some states. Therefore, representative signals were selected for detection and analysis to evaluate the feasibility of the proposed approach.

A signaling machine indicates whether the train should move forward or stop and is usually located at the beginning of the approach, to the left of the line running direction. Signaling machines can be divided into inbound, outbound, shunting, and other types, with displayed states including RL, BL, RDL, BLFS, DRL, and so on. A turnout directs vehicles from one track to another and has two positional states, positioning (SG) and reverse positioning (SY). Track circuits use railway tracks as conductors to form signal transmission circuits, which continuously monitor section occupancy; they can be idle (LB), occupied (LR), or incoming (LSB) states.

5.2. Automatic Annotation System

An automatic annotation system is developed for interlocking computer signal targets based on digital image processing. Using the color and morphological characteristics of signaling machines, turnouts, and track lines, and combining HSV color space analysis, morphological feature extraction, and coordinate mapping, the system identifies each signal element and determines its state. Color analysis focuses on the distinct color attributes of each signal, including distribution, hue variation, and texture patterns. Morphological analysis emphasizes contours, boundaries, and geometric properties, particularly for low-resolution targets. Positional analysis determines the type of signal by computing the coordinates of the center point within the HSV-based color mask, enabling precise localization and classification.

The data set generated by the automatic annotation subsystem consists of 1092 samples covering a variety of states and is used, after manual verification, to train the detection network. This pipeline substantially reduces manual labeling effort while maintaining label quality under variations such as window jitter and mouse occlusion.

5.3. Dataset Partition and Evaluation Protocol

The 1092 annotated images are partitioned at the image level into a training set (764 images, $70.0\%$), a validation set (109 images, $26,808$ instances, $10.0\%$), and a held-out test set (219 images, $53,625$ instances, $20.0\%$). On the test split, the per-class instance counts are RL 4409; BL 5158; RDL 429; DRL 4913; BLFS 416; SG 5398; SY 3040; LB $25,530$; LR 2558; LSB 1774, exhibiting a $61:1$ imbalance ratio between LB and BLFS. Because all images derive from the same continuous on-board video, the partition is performed by sampling non-adjacent frames into each split so that no two visually-near-duplicate frames straddle the train/test boundary.

The training set is used for back-propagation only. The validation set is used exclusively for model selection: it is evaluated at the end of every training epoch, and the highest-mAP@50 checkpoint is saved as the final model with early stopping (patience 50). The test set is held out and is never consulted during training or model selection; it is evaluated only once per final model. Accordingly,

Table 2. Component-wise ablation on the validation set. The proposed YOLOv8-SFF (Row 8, shaded in blue) integrates all three components and corresponds to the YOLOv8-ASF-P2 configuration. Parameters and GFLOPs are deterministic and reported once for the deployed model. Detection metrics are reported as mean ± standard deviation across three independent training runs with random seeds $\{0,1,42\}$ and otherwise-identical hyperparameters. Bold indicates the highest mean value in each metric column; differences within one standard deviation are statistically equivalent. The italic mAP@50 column marks the primary evaluation metric (see Section 6.2). In the header, “#” denotes the configuration index and a checkmark (✔) indicates the inclusion of the corresponding component.

#	P2	SSFF	TFE	Params (M)	GFLOPs	mAP@50 (%)	P (%)	R (%)
1	–	–	–	3.01	8.1	87.37 ± 1.39	91.65 ± 0.70	75.33 ± 3.76
2	✔	–	–	2.92	12.2	98.63 ± 0.08	97.70 ± 0.33	97.19 ± 0.36
3	–	✔	–	3.04	8.3	87.53 ± 0.63	91.73 ± 1.67	76.16 ± 2.70
4	–	–	✔	3.02	8.3	87.43 ± 0.68	92.77 ± 0.86	74.27 ± 1.17
5	✔	✔	–	2.46	11.8	98.64 ± 0.02	97.69 ± 0.40	97.25 ± 0.13
6	✔	–	✔	2.45	11.5	98.52 ± 0.04	97.51 ± 0.45	97.15 ± 0.32
7	–	✔	✔	3.05	8.5	86.85 ± 0.32	93.22 ± 0.45	73.76 ± 0.84
8	✔	✔	✔	2.49	12.0	98.66 ± 0.08	97.24 ± 0.48	97.39 ± 0.09

reports validation-set metrics to align with the model-selection criterion, while

Table 3. Held-out test-set verification of the eight ablation configurations. The proposed YOLOv8-SFF (Row 8, shaded in blue) was never exposed to the test set during training or model selection. Metrics are reported as mean ± standard deviation across three independent training runs with random seeds $\{0,1,42\}$ and otherwise-identical hyperparameters. Bold indicates the highest mean value in each metric column (ties on the rounded mean are both bolded); differences within one standard deviation are statistically equivalent. The italic mAP@50 column marks the primary evaluation metric (see Section 6.2). In the header, “#” denotes the configuration index and a checkmark (✔) indicates the inclusion of the corresponding component.

#	P2	SSFF	TFE	mAP@50 (%)	mAP@50:95 (%)	P (%)	R (%)
1	–	–	–	87.20 ± 1.33	70.36 ± 1.31	91.64 ± 1.84	74.90 ± 3.92
2	✔	–	–	98.67 ± 0.03	86.86 ± 0.39	97.61 ± 0.33	97.36 ± 0.27
3	–	✔	–	87.32 ± 0.89	71.06 ± 1.30	90.84 ± 2.09	75.71 ± 3.12
4	–	–	✔	87.30 ± 0.58	69.29 ± 0.71	93.46 ± 0.06	73.81 ± 0.78
5	✔	✔	–	98.65 ± 0.02	86.70 ± 0.10	97.63 ± 0.40	97.47 ± 0.07
6	✔	–	✔	98.53 ± 0.06	85.62 ± 0.18	97.63 ± 0.44	97.20 ± 0.36
7	–	✔	✔	86.63 ± 0.46	69.68 ± 0.44	93.19 ± 0.78	72.65 ± 0.45
8	✔	✔	✔	98.67 ± 0.04	86.74 ± 0.10	97.45 ± 0.12	97.36 ± 0.23

reports the corresponding held-out test-set metrics.

6. Experiments

Section 6.1 and Section 6.2 establish the experimental and evaluation protocol; the subsequent subsections each open with the design of a specific experiment and immediately report its numerical or qualitative result.

6.1. Implementation Details

All training and evaluation runs were executed on a single NVIDIA RTX 4090 GPU (24 GB) using PyTorch 2.0.1 under Python 3.8 and CUDA 11.7; channel pruning is performed through the torch-pruning 1.3.7 library. Rather than training from scratch, each model is initialised with the publicly released YOLOv8n ImageNet pre-trained weights and is then fine-tuned on the interlocking signal dataset. Input images are resized to $640\times 640$ pixels and grouped into mini-batches of eight samples; optimisation proceeds for up to 300 epochs, with early stopping triggered after 50 epochs of no improvement on the validation mAP@50. We adopt SGD with initial learning rate ${\mathrm{lr}}_0=0.01$ decayed linearly to a final factor ${\mathrm{lr}}_f=0.01$, momentum $0.937$, weight decay $5\times {10}^{-4}$, and a three-epoch linear warm-up. To support the multi-seed mean–std ablation analysis of Section 6.3, each of the eight configurations in Table 2 is trained three times under deterministic kernels with random seeds $\{0,1,42\}$ and otherwise-identical hyperparameters; the autogenerated args.yaml files of the 24 runs are byte-identical except for the seed field. Mixed-precision (AMP) training is used throughout. The augmentation pipeline follows the default YOLOv8 recipe—mosaic (probability $1.0$, disabled during the final 10 epochs), HSV jitter, geometric translation, scaling, horizontal flipping, and RandAugment—while mixup and copy-paste are turned off. For the two-stage compression pipeline of Section 4, the LAMP pruning stage (Equations (5) and (6)) runs with global pruning enabled, no per-layer sparsity cap, 200 iterative pruning steps, and a 500-epoch sparsity-learning warm-up applying an ${\ell }_2$ regulariser of strength $\lambda =5\times {10}^{-4}$ with linear decay $\delta =0.1\lambda$ every 10 epochs; the Speedup target is swept over $\{1.0,1.5,2.0,2.5\}$ with the $2.5\times$ configuration adopted as the final deployment model, and the pruned model is fine-tuned for 300 epochs with ${\mathrm{lr}}_0=0.01$ and patience 50 under the same SGD optimiser. The subsequent CWD distillation stage (Equations (7) and (8)) uses the unpruned YOLOv8-SFF as the teacher and the LAMP-pruned model as the student; the feature-level KL loss is applied at distillation layer indices $\{13,17,20,23,28\}$ with temperature $\tau =1.0$ and a constant feature-loss weight of $0.4$, with distillation proceeding for 250 epochs at batch size 8 under the same optimiser. All hyperparameter values above are taken from the auto-saved args.yaml files and are reproducible from the released scripts.

6.2. Performance Metrics

Our evaluation tracks both accuracy and efficiency metrics: precision, recall, mean average precision at IoU $=0.5$ (mAP@$0.5$), the parameter count, GFLOPs, on-disk model size, and the per-frame inference rate (FPS). Recall captures the fraction of ground-truth positives that the detector successfully recovers, while precision measures the fraction of detector outputs that are genuine positives. Average precision (AP) corresponds to the area under the precision–recall curve for one class, and the mean average precision (mAP) is obtained by averaging AP across all categories. We adopt mAP@50 as the primary evaluation metric throughout this work—it matches the operational tolerance of the downstream interlocking decision logic and is typeset in italic in Table 2 and Table 3; mAP@50:95 is reported for completeness:

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

(9)

$$AP={\int }_0^{1}P\left(R\right)dR,$$

(10)

$$P={\displaystyle \frac{TP}{TP+FP}},$$

(11)

$$mAP={\displaystyle \frac{{\sum }_{i=1}^{N}A{P}_i}{N}},$$

(12)

where $TP$, $FP$, and $FN$ are true positives, false positives, and false negatives, and N is the number of categories. GFLOPs quantifies the computational cost of a single forward pass.

6.3. Ablation Study

To isolate each component’s contribution, we conducted a complete $2^3$ factorial ablation over all eight subsets of {P2, SSFF, TFE}. The proposed YOLOv8-SFF integrates all three; YOLOv8-ASF is the SSFF+TFE combination without P2 [16]. Each configuration is trained three times with random seeds $\{0,1,42\}$ under otherwise-identical hyperparameters, and reported as mean ± standard deviation (Table 2 for validation, Table 3 for the held-out test split).

Three findings emerge. First, the P2 detection head is the dominant contributor: adding P2 alone to the YOLOv8 baseline lifts validation mAP@50 from $87.37\pm 1.39$ to $98.63\pm 0.08$ (a $+11.3$ pp gain), and the per-seed standard deviation drops from $1.39$ pp to $0.08$ pp, confirming that signal targets reside predominantly at the P2 stride-4 scale and that the high-resolution head also stabilises optimisation. Second, without P2 the multi-scale fusion modules contribute little: SSFF, TFE, and the original ASF block (Rows 3, 4, 7) all remain within one $\sigma$ of the baseline. Third, on top of P2 the four configurations (Rows 2, 5, 6, 8) cluster within $0.14$ pp on both validation and test mAP@50, with all pairwise differences at most $\sim 2\times$ the larger of the two standard deviations; the proposed full SFF attains the highest mean validation mAP@50 ($98.66\pm 0.08$) and ties P2-only at the top of the test mAP@50 (both $98.67$). On the stricter mAP@50:95 metric, adding TFE on top of P2 alone (Row 6) introduces a $\sim 1.2$ pp localisation drift relative to P2 alone ($85.62$ vs. $86.86$); re-introducing SSFF in the full SFF recovers this loss almost completely ($86.74\pm 0.10$, within $0.12$ pp of the P2-only ceiling), justifying retaining both modules in the proposed design.

Table 3 confirms that the validation-set ranking transfers to the held-out test split (SFF and P2-only both reach $98.67\%$ test mAP@50, within run-to-run variance); per-class robustness is analysed in Section 6.4.

6.4. Confusion-Matrix Analysis

All ten classes reach ≥0.92 on-diagonal recall (Figure 7): RDL, DRL and SG at $1.00$; BLFS and SY at $0.99$; shunting and track classes between $0.92$ and $0.97$, with LSB at the low end. The dominant cross-class confusion is the RL↔BL pair (3–$4\%$ in each direction; two operational states of the same shunting signal differing only in colour); every other off-diagonal cell is ≤0.01, and the safety-critical RDL/DRL/BLFS classes show zero confusion with other operational states. Missed detections are bounded by $7\%$ on LSB and ≤4% on every other class; false positives concentrate on the populous LB class (per-instance FP rate ≈ 2.1%, $534/24,725$).

6.5. Comparative Experiments

Table 4. Comparison experiment results. YOLOv8-SFF metrics are the mean across three random seeds $\{0,1,42\}$ (per-seed standard deviation $\le 0.1$ pp, see Table 2); the four baseline detectors are single-run as published. The proposed YOLOv8-SFF row is shown in bold to highlight the proposed method.

Model	P (%)	R (%)	mAP50 (%)	Parameters	FPS	Model Size (MB)
YOLOv5n	72.8	82.3	83.7	1,777,447	42.92	3.8
YOLOv7-tiny	65.3	70.8	64.5	6,039,342	62.89	12.3
YOLOv9-tiny	90.6	74.2	86.4	2,620,460	25.38	6.1
RT-DETR-tiny	99.1	99.2	99.3	19,884,600	17.30	40.5
YOLOv8-SFF	97.2	97.4	98.7	2,490,488	60.40	5.1

compares YOLOv8-SFF with several representative detectors, including YOLOv5n, YOLOv7-tiny, YOLOv9-tiny, and RT-DETR-tiny, on our interlocking signal dataset. YOLOv5n, YOLOv7-tiny, and YOLOv9-tiny exhibit lower precision and recall, yielding higher miss rates. RT-DETR-tiny reaches higher accuracy, but at roughly an order of magnitude more parameters and substantially lower throughput. YOLOv8-SFF offers the best overall balance of accuracy, model size, and real-time performance, running at 60 FPS with a footprint of 5.1 MB.

6.6. Pruning and Distillation Results

We evaluate the proposed joint compression pipeline on YOLOv8-SFF at four Speedup levels.

Table 5. Results of LAMP pruning on YOLOv8-SFF (no distillation). Speedup denotes the target compression level specified to the pruning tool; the Speedup $=1.0$ configuration corresponds to the mildest pruning setting rather than no pruning.

Speedup	P (%)	R (%)	mAP50 (%)	FPS	Parameters	GFLOPs	Model Size (MB)
1.0	54.3	60.3	57.6	44.8	933,387	7.9	2.2
1.5	42.4	34.8	33.0	46.1	575,875	6.0	1.5
2.0	19.2	7.4	11.3	47.9	433,017	4.8	1.2
2.5	10.5	0.7	0.2	48.2	345,022	4.0	1.1

reports results for LAMP pruning alone, and

Table 6. Results after CWD distillation on the LAMP-pruned YOLOv8-SFF. Speedup denotes the target compression level specified to the pruning tool; the Speedup $=1.0$ configuration corresponds to the mildest pruning setting rather than no pruning. The finally adopted deployment configuration (Speedup $=2.5$) is shown in bold.

Speedup	P (%)	R (%)	mAP50 (%)	FPS	Parameters	GFLOPs	Model Size (MB)
Baseline	98.0	96.6	98.2	60.4	2,490,488	12.0	5.1
1.0	97.9	97.6	98.7	56.6	929,905	7.9	2.2
1.5	97.2	97.7	98.6	58.2	573,110	6.0	1.5
2.0	96.8	97.0	98.5	60.9	430,615	4.7	1.2
2.5	96.5	96.8	98.0	61.0	342,875	3.9	1.1

reports results after CWD distillation.

Several observations can be drawn from Table 5 and Table 6. First, LAMP pruning alone causes substantial accuracy loss at aggressive compression rates: at Speedup $=2.5$, mAP collapses to near zero, confirming that pruning must be followed by a recovery stage. A layer-wise inspection of the pruned weights further indicates that LAMP allocates sparsity adaptively across layers, with deeper convolutional stages pruned more aggressively than shallow ones, consistent with the layer-adaptive design of the method. Second, CWD distillation effectively restores accuracy in all Speedup settings. At Speedup $=1.0$–$2.0$, the distilled models even slightly surpass the original YOLOv8-SFF on mAP50, likely because distillation also acts as a form of regularization. Third, in Speedup $=2.5$, the distilled model retains 98.0% mAP while reducing the parameters from 2.49 M to 0.34 M (an 86.2% reduction) and the size of the model from 5.1 MB to 1.1 MB, and still runs above 60 FPS. This combination of accuracy, size, and speed makes the compressed model well suited for deployment on embedded dispatching terminals.

6.7. Detection Results

As shown in Figure 8, the original YOLOv8 suffers from noticeable missed detections, especially on turnouts and signaling machines, with relatively low detection confidence. In contrast, Figure 9 shows that the proposed YOLOv8-SFF accurately identifies signaling machines, turnouts and track signals, despite the small size and low resolution of the interlocking signals. These results indicate that the proposed framework can provide valuable signal analysis support for metro dispatching.

7. Discussion

The experimental results demonstrate that the proposed YOLOv8-SFF model significantly outperforms the baseline YOLOv8 model in detecting small-signal targets within metro computer interlocking systems. The substantial improvements in recall (by 25.3%) and mAP@50 (by 11.8%) can be primarily attributed to the architectural enhancements introduced in this study. Specifically, the addition of a small-target detection head effectively mitigates the information loss caused by the small size and low resolution of signal indicators. Furthermore, the incorporation of the SSFF and TFE modules enhances multi-scale feature fusion, allowing the model to preserve fine-grained spatial details that are otherwise easily discarded during deep downsampling operations. The removal of redundant concatenation and upsampling operations not only streamlines the network but also prevents overfitting to irrelevant noise, thereby improving detection efficiency without compromising accuracy. Nevertheless, the increased computational overhead from additional detection heads and modules may pose deployment challenges. Future work should therefore explore lightweight architectures and domain adaptation techniques to enhance robustness under degraded imaging conditions.

8. Conclusions

In this paper, a multi-scale feature fusion target detection model YOLOv8-SFF is proposed specifically for small-signal target detection in metro computer interlocking systems. To address the limitations of the original YOLOv8 model in detecting low-resolution signal targets, we introduced a small-target detection head, integrated SSFF and TFE modules for enhanced feature fusion, and optimized the network structure by removing redundant operations. Experimental results on real-world metro signal data demonstrate that the proposed model achieves an improvement in recall and mAP@50 compared to the baseline YOLOv8 model, effectively mitigating missed detections. Future work will focus on reducing model complexity and validating generalization performance under more diverse and complex operational scenarios.