Fast Identification of Series Arc Faults Based on Singular Spectrum Statistical Features

Abstract

Series arc faults are a major cause of electrical fires, posing significant risks to life and property. Their negative-resistance characteristics make fault features difficult to detect, and the existing methods often suffer from high false-alarm rates, poor adaptability, and reliance on high sampling rates and long sampling windows. To enhance the accuracy and efficiency of series AC arc fault detection, this paper proposes a rapid identification method based on singular spectrum statistical features and a differential evolution-optimized XGBoost classifier. The approach first constructs the singular spectrum of current waveforms via a Hankel matrix singular value decomposition and extracts nine statistical features. It then optimizes seven XGBoost hyperparameters using differential evolution to build an efficient classification model. The experiments on 18,240 current samples covering 16 load conditions (including eight arc fault types) show that the method achieves an average identification accuracy of 98.90% using only three nominal cycles (60 ms) of current waveform. Even with a training set ratio as low as 5%, it maintains 97.11% accuracy, outperforming Back-propagation Neural Network, Support Vector Machine, and Recurrent Neural Network methods by up to three percentage points. The method avoids the need for high sampling rates or complex time–frequency transformations, making it suitable for resource-constrained embedded platforms and offering a generalizable solution for series arc fault detection.

1. Introduction

Electrical fires pose severe threats to life and property, garnering global concern. According to statistics, China alone recorded over 85,000 electrical fire incidents in 2020, accounting for 33.6% of total fire accidents [1]. With increasing electricity consumption and aging cable infrastructure, the incidence of electrical fires continues to rise [2]. Among all contributing factors, fault arcs are the primary cause—their extreme temperatures readily ignite surrounding combustibles (e.g., wooden structures or insulation materials), subsequently triggering fires [3,4]. Therefore, arc fault detection and identification are critical for electrical safety, playing vital roles in hazard prevention and fire risk mitigation.

The detection of series arc faults is still highly challenging. This is mainly because their negative-resistance characteristics cause a decrease in the current (rather than an increase) and an increase in the impedance [5,6], resulting in extremely subtle fault features. Moreover, the current amplitude of series arcs is much smaller than that of parallel arcs. These characteristics make traditional overcurrent-based protection devices (such as fuses and molded case circuit breakers) ineffective for their detection [7]. More critically, the weak current signatures of series arc faults are easily masked by the normal current characteristics of loads, further increasing the difficulty of accurate identification. Nevertheless, despite being difficult to detect, series arcs can quickly generate localized hot spots, leading to rapid temperature rises and posing a serious fire hazard, highlighting the urgency of addressing their detection challenges.

To address the challenges of series arc fault identification, researchers have proposed various methods, which can be broadly categorized into time-domain approaches, frequency-domain approaches [8,9], and machine learning-based algorithms. Time-domain methods detect faults by analyzing the voltage/current waveform characteristics [10,11], including the current amplitude, rate of change, derivatives, and Tsallis entropy [12,13,14,15], as well as statistical measures (e.g., standard deviation), distribution shapes (e.g., skewness, kurtosis), zero-crossing detection, mean square error, and mean energy density [16,17,18,19,20]. Frequency-domain methods, on the other hand, utilize spectral distribution information—such as harmonic and interharmonic parameters—for detection. Feature extraction techniques primarily include Fast Fourier Transform (FFT) [21,22,23], Wavelet Transform [16,17,24,25,26], Hilbert–Huang Transform [27], and Chirp Z-Transform [28]. However, these methods are often effective only under specific operating conditions, require preset thresholds, and lack a universal standard for determining the optimal feature set, which limits their applicability.

With the rapid development of artificial intelligence, machine learning-based methods have become a research hotspot in arc fault detection. These methods train classification models to adaptively distinguish between normal and fault states and can integrate multiple feature parameters to enhance reliability. Classical approaches, such as Support Vector Machines (SVMs) [29,30], offer good robustness and are well suited for small sample sizes; for example, [31] combined an SVM with the current’s kurtosis features to achieve 97.17% accuracy. However, SVMs are limited in handling multi-class problems and high-dimensional features [32]. Decision trees, as used in [33], exploit their ability to process high-dimensional features, achieving 97.81% detection accuracy. An advanced variant, the Random Forest (RF) [34], performs excellently on complex feature classification and has been applied to fault pattern recognition. In [35], an RF was employed for feature selection in combination with XGBoost for fault identification, yielding high accuracy and demonstrating RF’s strong applicability and robustness in multi-class problems. Neural network-based algorithms, such as Backpropagation Neural Networks (BPNNs) [36,37], Convolutional Neural Networks (CNNs) [7,38,39], and Recurrent Neural Networks (RNNs) [40], also perform well for complex pattern recognition. They can extract distribution features and even process waveform images directly; however, they suffer from long training times, weak generalization, and high computational resource consumption in real-time detection.

Despite notable progress, current series arc fault detection methods still face several critical limitations. Many time-domain and frequency-domain techniques exhibit strong dependence on specific operating conditions, require carefully tuned thresholds, or lack a unified standard for optimal feature selection, leading to reduced robustness under complex and variable loads. Machine learning approaches, although capable of integrating multiple features, often demand extensive training data, incur high computational costs, and may struggle with generalization in real-time applications. Moreover, a common drawback across the existing methods is the reliance on high sampling rates and long observation windows, which hinders their deployment on low-cost embedded platforms. These challenges underscore the need for a lightweight, fast, and accurate identification solution with strong adaptability to diverse load conditions.

To address the aforementioned challenges, this work develops a fast series AC arc fault identification approach that leverages singular spectrum statistical features combined with a differential evolution-optimized XGBoost classifier. Unlike mainstream techniques, the proposed method extracts the statistical features from the singular spectrum of current waveforms under diverse fault conditions, capitalizing on the rich frequency components and high amplitudes of arc currents while eliminating the dependencies on long sampling windows for time–frequency transforms. This enables its effective adaptation to varied load scenarios and delivers rapid, precise identification. The experimental results demonstrate that the method achieves high recognition accuracy (98.90% with only 60 ms of data) and maintains robust performance even with minimal training samples, thereby addressing key gaps in current research. The main contributions of this work are listed as follows.

(1) A novel feature extraction method for fault arcs is proposed. This method constructs a Hankel matrix from the sampled current sequence of a fault arc and extracts nine singular spectrum statistical features from the matrix. In contrast to traditional feature extraction approaches based on time–frequency transforms or modal decomposition, the proposed method demonstrates advantages, including fewer required features and computational simplicity.

(2) A fast and accurate fault arc identification solution is designed. Operating at a sampling frequency of 5 kHz, this solution achieves the precise identification of eight types of fault arcs using only three nominal cycles (i.e., 60 ms). Its exceptional real-time performance gives it significant potential for application in low-cost, resource-constrained embedded hardware platforms.

(3) The effectiveness of the proposed solution is validated using real-world data from a fault arc experimental platform. The experimental results demonstrate that the solution offers the advantages of requiring fewer training samples and achieving high fault arc recognition accuracy.

2. Feature Extraction from Singular Spectrum Statistical Features

When a series arc fault occurs, the current waveform becomes distorted, increasing the harmonic and interharmonic components. For a Hankel matrix constructed from current sampling sequences, the singular values in its singular spectrum are proportional to the amplitudes of these harmonic components [41]. Different arc fault conditions produce distinct harmonic characteristics in terms of frequency, quantity, and amplitude, which are reflected in the singular values and manifest as unique singular spectrum patterns. Consequently, statistical features of a singular spectrum can effectively extract the signal characteristics for various arc faults.

The series fault arc identification method proposed in this paper is established based on the singular spectrum features of current waveforms. Its statistical feature extraction primarily consists of two parts: (1) constructing the singular spectrum and (2) extracting the statistical feature indices from the singular spectrum.

2.1. Singular Spectrum Construction

For a time-domain sampling sequence of fault arc current waveforms, denoted as y = [y(1), y(2), y(3), …, y(n), …, y(N)], an (N − L) × (L) Hankel matrix can be constructed as follows:

$$\mathit{Y}=\left[\begin{array}{cccc}y(1)& y(2)& \dots & y(L)\\ y(2)& y(3)& \dots & y(L+1)\\ ⋮& ⋮& \dots & ⋮\\ y(N-L)& y(N-L+1)& \dots & y(N)\end{array}\right]$$

(1)

where N denotes the number of sampling points in the current sequence, and N/3 ≤ L ≤ N/2. For simplicity, this paper adopts the configuration L = fix(N/2), where fix(·) is the rounding operation. The Hankel matrix Y undergoes singular value decomposition as follows:

$$\mathit{Y}=\mathit{U}{\mathit{S}}_{\mathrm{all}}{\mathit{V}}^{\mathrm{H}}$$

(2)

where U_{(N − L)} $\times$ _{(N − L)} and V_(L) $\times$ _(L) are unitary matrixes, and S_all is an (N − L) × (L) diagonal matrix whose diagonal elements are the singular values of Y, expressed as

$$S_{\mathrm{all}}={\left[\begin{array}{l}{S}_1\\ S_2\end{array}\right]}_{\left(N-L\right)\times \left(L\right)}$$

(3)

where S₂ is an (N − 2L) × (L) zero matrix, and S₁ is an L × L diagonal matrix.

$$S_1=\left[\begin{array}{cccccc}{\sigma }_1& & & & & \\ & {\sigma }_2& & & & \\ & & \ddots & & & \\ & & & {\sigma }_l& & \\ & & & & \ddots & \\ & & & & & {\sigma }_L\end{array}\right]$$

(4)

where σ₁ > σ₂ > … > σ_l > … ≥ σ_L. For notational simplicity, the collection of singular values along the diagonal of S₁ may be reformulated as a singular spectral representation:

$$S=\left[{\sigma }_1,{\sigma }_2, \cdots ,{\sigma }_l,\cdots {\sigma }_L\right]$$

(5)

2.2. Statistical Feature Extraction

During fault arc incidents, the current waveform exhibits numerous high-amplitude harmonics and interharmonics. Since singular values positively correlate with the amplitudes of multifrequency signal components, the statistical features of the singular energy spectrum can serve as the key identifiers for fault arcs. The proposed identification method extracts nine statistical features (a–i) from the singular energy spectrum as follows:

(a) Energy:

$$E={\displaystyle \sum _{l=1}^L{\left|{\sigma }_l\right|}^2}$$

(6)

(b) Mean:

$$M={\displaystyle \frac{1}{L}}{\displaystyle \sum _{l=1}^L{\sigma }_l}$$

(7)

(c) Standard Deviation:

$$S_{\mathrm{td}}=\sqrt{{\displaystyle \frac{1}{L}}{\displaystyle \sum _{l=1}^L{\left({\sigma }_l-M\right)}^2}}$$

(8)

(d) Skewness:

$$S_{\mathrm{kew}}=\sqrt{{\displaystyle \frac{1}{6L}}{\displaystyle \sum _{l=1}^L{\left(\frac{{\sigma }_l-M}{S_{\mathrm{td}}}\right)}^3}}$$

(9)

(e) Shannon Entropy:

$$S_{\mathrm{E}}=-{\displaystyle \sum _{l=1}^L{\sigma }_l^2\log \left({\sigma }_l^2\right)}$$

(10)

(f) RMS:

$$R_{\mathrm{ms}}=\sqrt{{\displaystyle \frac{1}{L}}{\displaystyle \sum _{l=1}^L{\sigma }_l^2}}$$

(11)

(g) Kurtosis:

$$K_{\mathrm{RT}}=\sqrt{{\displaystyle \frac{L}{24}}}\left({\displaystyle \frac{1}{L}}{\displaystyle \sum _{l=1}^L{\left(\frac{{\sigma }_l-M}{S_{\mathrm{td}}}\right)}^4-3}\right)$$

(12)

(h) Log-energy Entropy

$$L_{\mathrm{OE}}={\displaystyle \sum _{l=1}^L\log \left({\sigma }_l^2\right)}$$

(13)

(i) Norm Entropy:

$$N_{\mathrm{E}}={\displaystyle \sum _{l=1}^L{\left({\sigma }_l\right)}^p}, 1\le p$$

(14)

The nine extracted singular spectrum statistical features are arranged into the following feature vector form:

$$F_{\mathrm{set}}=\left[E,M,S_{\mathrm{td}},S_{\mathrm{kew}},S_{\mathrm{E}},R_{\mathrm{ms}},K_{\mathrm{TR}},L_{\mathrm{OE}},N_{\mathrm{E}}\right]$$

(15)

3. Series Arc Fault Rapid Identification

3.1. XGBoost Classifier

XGBoost is a highly efficient machine learning algorithm based on distributed gradient boosting, belonging to the scalable tree boosting systems family [42]. It is primarily designed for supervised learning tasks. For a given classification task, its dataset D can be represented as follows:

$$D={\left\{\left(x_i,y_i\right)\right\}}_{i=1}^n,x_i\in {ℝ}^m,y_i\in \mathcal{Y}$$

(16)

where n denotes the number of records in the dataset and x_i is composed of the singular spectrum feature set (F_set) derived from the fault arc current waveform. Thus, it follows that

$$x_i=\left[x_i^{(1)},x_i^{(2)},\dots ,x_i^{(m)}\right]$$

(17)

where $x_i^{(j)}\in F_{\mathrm{set}}$ and m denotes the number of the extracted statistical features from the singular spectrum. When integer labels are applied, then $\mathcal{Y}=\left\{1,2,\cdots ,16\right\}$. $\mathcal{Y}$ refers to the label space, corresponding to 16 categories of fault arc current waveforms. For detailed information, refer to the dataset description in Section 4.

Taking the dataset D = {(x₁, y₁), (x₂, y₂), …, (x_i, y_i), …, (x_N, y_N)} as an example, the output of the tree ensemble model based on T prediction functions fₜ can be expressed as follows:

$${\widehat{y}}_i={\displaystyle \sum _{t=1}^K{f}_t}({\mathit{x}}_i),f_t\in \mathcal{F}$$

(18)

where $\mathcal{F}$ is the function space containing all classification trees; K denotes the total number of training rounds, which is a hyperparameter set prior to training.

XGBoost employs additive learning rather than weight learning as in traditional tree models, with its objective function formulated as

$$\mathrm{Obj}={\displaystyle \sum _{i=1}^{n}l}\left(y_i,{\widehat{y}}_i\right)+{\displaystyle \sum _{t=1}^K\mathrm{\Omega }}\left(f_t\right)$$

(19)

where

$$\mathrm{\Omega }\left(f_t\right)=\gamma T\left(f_t\right)+{\displaystyle \frac{1}{2}}\lambda {\displaystyle \sum _{j=1}^{T\left(f_t\right)}{w}_j^2}$$

(20)

where t = 1, 2, …, K, denotes the t-th tree in the boosting sequence; l(·) is the loss function quantifying the model’s fit to the training data, with multi-class cross-entropy adopted as the loss function in this work; Ω(·) represents the regularization term assessing model complexity; T(f_t) indicates the number of leaf nodes in the current tree f_t; and w_j corresponds to the weight value of the j-th leaf node. Note that T(f_t) explicitly signifies the leaf count determined by the structure of the t-th tree, where f_t also denotes the tree function under construction, which inherently encapsulates the sample-to-leaf mapping structure and splitting paths. Building upon gradient-boosted decision trees (GBDTs), XGBoost incorporates L1 and L2 regularization terms to effectively suppress model overfitting.

The XGBoost classifier is trained in an additive manner. Let ${\widehat{y}}_i^{(t)}$ denote the predicted value for the i-th sample at the t-th iteration. Conditioned on the first t − 1 trees, the objective function at the t-th iteration reduces to

$$L^{(t)}={\displaystyle \sum _{i=1}^{n}l}\left(y_i,{\widehat{y}}_i^{(t-1)}+f_t\left({\mathrm{x}}_i\right)\right)+\mathrm{\Omega }(f_t)$$

(21)

Applying the second-order Taylor expansion to the loss function [42,43], one obtains

$$L^{(t)}\approx {\displaystyle \sum _i^n\left[\begin{array}{c}l\left(y_i,{\widehat{y}}^{(t-1)}\right)+\\ g_i{f}_t\left({\mathit{x}}_i\right)+\frac{1}{2}{h}_i{f}_t^2\left({\mathit{x}}_i\right)\end{array}\right]}+\mathrm{\Omega }\left(f_t\right)$$

(22)

where g_i and h_i are the first-order and second-order gradient statistics of the loss function, respectively, defined as

$$g_i={\partial }_{{\widehat{y}}^{(i-1)}}l\left(y_i,{\widehat{y}}^{(t-1)}\right)$$

(23)

$$h_i={\partial }_{{\widehat{y}}^{(t-1)}}^{2}l\left(y_i,{\widehat{y}}^{(t-1)}\right)$$

(24)

Define q(x_i) as the structure function of the current tree that assigns the input sample x_i to its corresponding leaf node index. If sample x_i resides in the j-th leaf node, then q(x_i) = j. Accordingly, let $I_j=\left\{i\right|q({\mathit{x}}_i)=j\}$ denote the set of training sample indices assigned to leaf node j. The term $l(y_i,{\widehat{y}}^{(t-1)})$ in Equation (22) is a constant and independent of the tree ft added in the current iteration. It can therefore be omitted during optimization of the objective function, which simplifies to

$$L^{(t)}\approx {\displaystyle \sum _{i=1}^n\left[g_i{f}_t\left({\mathit{x}}_i\right)+\frac{1}{2}{h}_i{f}_t^2\left({\mathit{x}}_i\right)\right]}+\mathrm{\Omega }(f_t)$$

(25)

In XGBoost classifiers, the function of each tree can be reformulated as $f_t({\mathit{x}}_i)=w_{q\left({\mathit{x}}_i\right)}$. Substituting the definition of $\mathrm{\Omega }(f_t)$ into the objective function yields

$$L^{(t)}\approx {\displaystyle \sum _{i=1}^n\left[g_i{w}_{q({\mathrm{x}}_i)}+\frac{1}{2}{h}_i{w}_{q({\mathrm{x}}_i)}^2\right]}+\gamma T(f_t)+{\displaystyle \frac{1}{2}}\mathsf{\lambda }{\displaystyle \sum _{j=1}^{T(f_t)}{w}_j^2}$$

(26)

Since $q({\mathit{x}}_i)=j$ holds for every leaf node j, aggregating the results by leaves yields

$$L^{(t)}\approx {\displaystyle \sum _{i=1}^n\left[{\displaystyle \sum _{i\in I_j}{g}_i}{w}_j+\frac{1}{2}{\displaystyle \sum _{i\in I_j}{h}_i}{w}_{q(x_i)}^2\right]}+\gamma T(f_t)+{\displaystyle \frac{1}{2}}\lambda {\displaystyle \sum _{j=1}^{T(f_t)}{w}_j^2}$$

(27)

Equation (25) becomes the optimization objective for the new decision trees. This constitutes the underlying mechanism enabling XGBoost to support custom loss functions. Its primary advantage lies in incorporating regularization terms into the loss function. Such a design yields more concise tree structures and mitigates overfitting.

3.2. Selection of Classifier Hyperparameters

The configuration strategy of classifier hyperparameters directly impacts a model’s performance and generalization capability. Notably, XGBoost involves over a dozen critical hyperparameters, making their combinatorial optimization a high-dimensional nonlinear optimization problem. Traditional grid search methods, requiring traversal of discrete parameter spaces, exhibit significant limitations in computational resource consumption and search efficiency. To balance exploration of parameter space and convergence speed, our approach employs a differential evolution algorithm implemented via the Scikit-Optimize library. This method adaptively optimizes seven core XGBoost hyperparameters through mutation and crossover mechanisms. By maintaining a dynamic parameter population, the strategy progressively approximates the global optimum, achieving ≈ 40% reduction in iterations compared to conventional methods. The search boundaries for each dimension, determined through a parameter sensitivity analysis and model convergence characteristics, yield the optimal parameter combination shown in

Table 1. The parameters of the adopted XGBoost classifier.

Parameters	Search Range	Optimal Selection
learning_rate	[0.02, 0.5]	0.1321
n_estimators	[10, 50]	17
max_depth	[5, 30]	10
subsample	[0.2, 1]	0.7921
colsample_bytree	[0.2, 1]	0.5934
reg_lambda	[0, 1]	0.8
min_child_weight	[0, 1]	0.4823

.

It should be noted that the hyperparameter search ranges in Table 1 are determined based on the feature dimensionality (nine dimensions). This specifically references successful examples in DE-based XGBoost classification applications where the feature dimensionality is close to nine [44]. During iterative optimization, we employ a threefold cross-validation, using the mean classification error rate on the test set as the optimization objective. For the DE settings, the number of iterations is set to 40. The population size is set to 35 following the 10 × D rule (where D represents the dimensionality of hyperparameters). During each mutation operation, the mutation factor for each individual is a random number uniformly sampled from the interval [0.3, 0.9], and the mutation strategy ‘best/1/bin’ is employed. The crossover probability is fixed at 0.5.

3.3. The Proposed Arc Fault Identification Method

The proposed arc fault identification methodology and workflow are illustrated in Figure 1. The implementation comprises two key components. I. Construction and Training of Arc Fault Identification Model: The detailed implementation steps are as follows: (1) collect the current waveforms of diverse arc fault types; (2) build the arc fault dataset based on the singular spectrum statistical features from the current waveforms; (3) split the dataset into training and testing subsets by the prescribed ratio; (4) utilize the singular spectrum feature vectors (nine features) as the XGBoost input, with category labels 1–16 as the prediction outputs; (5) pre-train using the XGBoost default parameters, then apply the differential evolution algorithm for iterative hyperparameter optimization; (6) terminate the optimization when the loss function reaches its minimum, configuring the optimal parameters; and (7) validate the optimized XGBoost model with the testing set. II. Arc Fault Identification Procedure: The detailed implementation steps are as follows: (1) acquire the real-time current waveforms at the specified sampling frequency within the observation window; (2) construct Hankel matrix Y from the current sampling sequence; (3) perform a singular value decomposition (SVD) on Y and compute the singular spectrum feature set F_set; and (4) feed F_set into the trained XGBoost classifier for arc fault identification.

4. Experimental Methods and Results Analysis

4.1. Experimental Platform and Dataset

To validate the effectiveness of the proposed method, actual fault arc current waveforms [30] were analyzed using the acquisition circuit depicted in Figure 2, which comprises a 220V AC power supply, a fault arc generation apparatus, a current waveform acquisition unit, household experimental loads, and a data analysis computer. It should be noted that the proposed method was validated using a public dataset [30]. The detailed hardware parameters and experimental procedures for the fault arc experimental platform are provided in Reference [30], with only a brief summary included here to avoid redundancy.

The arc fault generator comprises a fixed electrode, a movable electrode, and a stepper motor for the precision adjustment of the inter-electrode gap. Precise displacement control of the adjustable slider via the stepper motor ensures full contact between the electrodes. After circuit energization, gradual separation of electrodes is achieved through progressive slider adjustment. When the inter-electrode distance reaches a critical threshold, sustained arc discharge occurs. The experimental system employs a 50 kHz sampling frequency, corresponding to 1000 samples per cycle at a 50 Hz power frequency.

Table 2. Parameters of adopted loads.

Load Types	Load Combination	Power/W
1	Electric Fan	60
2	Incandescent Lamp	300
3	Dust Catcher	1100
4	Evaporative Cooling Fan	65
5	Monitor	18
6	Electric Fan + Monitor	60 + 18
7	Evaporative Cooling Fan + Monitor	65 + 18
8	Electric Fan + Evaporative Cooling Fan + Monitor	60 + 65 + 18

details the experimental load configurations, while Figure 3 visually contrasts the current waveforms under normal operation versus arc fault conditions. Notably, compared to regular load operations, the fault arc currents exhibit significantly elevated amplitudes and markedly complex frequency-domain components.

4.2. Evaluation Metrics

To evaluate the performance of the proposed method, we employ well-established evaluation metrics used in machine learning classification: accuracy, precision, recall, and F1-score. The accuracy measures the proportion of correctly classified instances relative to the total samples, defined as follows:

$$\mathrm{Accuracy}={\displaystyle \frac{TP+TN}{TP+TN+FN+FP}}$$

(28)

where TP, TN, FP, and FN represent the counts of true positives, true negatives, false positives, and false negatives, respectively.

The F1-score is a practical metric well-suited for imbalanced data, and must be computed individually for each category of fault current. For the i-th category of fault current, its F1-score is defined as follows:

$$F{1}_i={\displaystyle \frac{2\cdot Precisio{n}_i\cdot Recal{l}_i}{Precisio{n}_i+Recal{l}_i}}$$

(29)

where

$$Precisio{n}_i={\displaystyle \frac{T{P}_i}{T{P}_i+F{P}_i}}$$

(30)

$$Recal{l}_i={\displaystyle \frac{T{P}_i}{T{P}_i+F{N}_i}}$$

(31)

4.3. Test Results

To ensure the real-time performance and effectiveness of the proposed method, parameter configuration must be considered during deployment. The arc fault identification process involves singular spectrum feature extraction, which requires SVD computation. Given the substantial computational load of SVD, downsampling is applied to the original 50 kHz current sampling sequence. This experiment sets the signal length per extraction to 3 nominal power cycles (60 ms, 3000 samples). Through uniform decimation, the sampling frequency is reduced to 10 kHz (600 samples). Consequently, for the Hankel matrix Y constructed in real-time, the computational complexity of SVD decreases from O(1500³) to O(300³), achieving significant time savings.

Prior to training the XGBoost classifier model, the sampled circuit current waveforms are partitioned into 16 distinct categories based on the load types and operating conditions. This classification comprises 8 classes for normal operation and 8 classes for fault arcs, with the fault arc dataset classification encoding detailed in

Table 3. Classifications and labels of fault arc dataset.

Load Types	Working Conditions	Label	Load Types	Working Conditions	Label
1	Normal	A1	5	Normal	E1
	Fault Arc	A2		Fault Arc	E2
2	Normal	B1	6	Normal	F1
	Fault Arc	B2		Fault Arc	F2
3	Normal	C1	7	Normal	G1
	Fault Arc	C2		Fault Arc	G2
4	Normal	D1	8	Normal	H1
	Fault Arc	D2		Fault Arc	H2

. In this experiment, a total of 18,240 current waveform samples are categorized into 16 classes, with 1140 samples per class. The dataset is divided into training and test sets at a 7:3 ratio for experimental validation. The training set facilitates parameter learning for the XGBoost classifier model, while the test set evaluates the method’s performance. The overall confusion matrix of test results is shown in Figure 4, and

Table 4. Evaluation indicators for fault arc recognition using the proposed identification method.

Label	Precision	Recall	F1-Score	Support
A1	1.00	0.99	1.00	342
A2	0.97	0.92	0.94	342
B1	1.00	1.00	1.00	342
B2	0.99	1.00	1.00	342
C1	1.00	1.00	1.00	342
C2	1.00	1.00	1.00	342
D1	1.00	1.00	1.00	342
D2	0.94	0.97	0.95	342
E1	1.00	1.00	1.00	342
E2	1.00	1.00	1.00	342
F1	1.00	1.00	1.00	342
F2	0.96	0.99	0.97	342
G1	1.00	1.00	1.00	342
G2	0.97	0.95	0.96	342
H1	1.00	1.00	1.00	342
H2	1.00	1.00	1.00	342
Accuracy	-	-	0.99	5472
Macro-Average	0.99	0.99	0.99	5472
Weighted Average	0.99	0.99	0.99	5472

details the performance metrics per fault arc category, including accuracy, precision, recall, F1-score, and support counts.

As evidenced by the test results in Figure 4 and Table 4, the proposed method achieved exceptionally high arc fault recognition success rates, with the macro-average, weighted-average, and overall classification accuracy for precision, recall, and F1-score all reaching 99%. Notably, four fault arc classes (B2, C2, E2, and H2) achieved 100% recall rates. Among all the fault categories, class A2 exhibited the lowest performance, with the precision, recall, and F1-score at 97%, 92%, and 94%, respectively. Class G2 performed slightly better than A2, with corresponding metrics of 97%, 95%, and 96%. This indicates that the feature extraction model retains potential for improvement in characterizing A2 and G2 fault types.

4.4. Validation with Varying Training Set Proportions

To evaluate the generalization capability of the proposed method, the dataset was partitioned into training and test sets at varying ratios, with the performance metrics analyzed across the different proportion configurations. In the experiments, the training set proportions were set at 5%, 10%, 20%, 40%, 70%, and 80%, corresponding to test set proportions of 95%, 90%, 80%, 60%, 30%, and 20%, respectively. The experimental results under each training–test set configuration are illustrated in Figure 5, Figure 6, Figure 7 and Figure 8.

As evidenced in Figure 5 through Figure 8, all the evaluation metrics for the proposed method demonstrate an upward trend with increasing test set proportions, with the precision rising from 97.14% to 98.91%, the recall improving from 97.11% to 98.90%, the F1-score increasing from 97.10% to 98.90%, and the overall recognition accuracy growing from 97.11% to 98.90%; notably, the performance metrics exhibit no further improvement when the training set proportion expands from 70% to 80%, and even with a minimal training set proportion of 5% (test set: 95%), the method maintains 97.11% overall accuracy, indicating that the singular spectrum statistical feature set captures the current characteristics of diverse fault arcs with minimal samples, exhibits a low dependence on classifier models, and demonstrates a strong generalization capability for fault arc classification applications.

4.5. Accuracy Comparison with Other Methods

To further validate the fault arc classification performance of the proposed approach, mainstream fault arc identification methods were experimentally selected as references for a comparative analysis of recognition accuracy under identical datasets and testing conditions. The reference methods encompassed three categories: Back-propagation Neural Network (BPNN), Support Vector Machine (SVM), and Recurrent Neural Network (RNN). The recognition success rates of each method across the different fault arc categories are detailed in

Table 5. Fault arc detection success rates of different methods.

Label	BPNN	SVM	RNN	Proposed
A1	89.16%	94.09%	93.32%	99.01%
A2	91.38%	93.45%	92.19%	92.17%
B1	93.14%	95.92%	96.21%	100.0%
B2	92.87%	97.78%	95.81%	100.0%
C1	93.87%	94.32%	97.23%	100.0%
C2	95.31%	97.83%	96.29%	100.0%
D1	92.45%	94.79%	95.16%	100.0%
D2	94.89%	93.13%	94.92%	97.39%
E1	93.78%	96.34%	95.24%	100.0%
E2	90.83%	95.41%	96.97%	100.0%
F1	91.22%	96.17%	97.89%	100.0%
F2	89.27%	94.86%	94.35%	99.13%
G1	94.26%	97.82%	95.87%	100.0%
G2	93.59%	95.31%	96.19%	95.34%
H1	91.29%	96.51%	95.86%	100.0%
H2	92.57%	97.35%	96.97%	100.0%

.

As evidenced in Table 5, all four recognition methods achieved average classification success rates exceeding 90% across 16 distinct operating conditions, with the proposed method generally demonstrating the highest performance—achieving 100% recognition rates in 10 scenarios while dipping to 92.17% only under condition A2; the SVM and RNN exhibited comparable success rates ranging between 93% and 98%, while the BPNN delivered the lowest performance (89–95%); benefitting from the distinctive singular spectrum statistical characteristics of current signals across diverse fault arc scenarios, the proposed fault arc identification method demonstrated substantial advantages over the BPNN, SVM, and RNN approaches.

4.6. Computational Complexity Analysis

To evaluate the real-time identification performance of the proposed method, a computational overhead analysis experiment was conducted. The hardware configuration included an Intel Core i7-10700F processor @ 2.9 GHz, 32 GB RAM, and a 64-bit windows 10 operating system. The software environment utilized PyCharm 2020 and Python 3.8. The comparative algorithms included classifiers based on BPNN [36,37], SVM [29,30], and RNN [40]. Among them, both the BPNN and SVM employed a wavelet transform (WT) for fault arc feature extraction, with the SVM additionally incorporating a multilayer perceptron (MLP). It should be noted that these comparative methods were implemented based on the approaches described in the literature rather than replicating the original solutions, for the following reasons: (1) The fault arc categories vary across these studies and do not uniformly cover all 16 classes. (2) The original literature does not provide detailed source code. (3) The use of identical datasets and runtime environments ensures the comparability of experimental results.

The average execution times of different methods over 1000 runs are shown in

Table 6. Execution time comparison averaged over 1000 runs.

Methods	WT-BPNN	WT-SVM	MLP-SVM	RNN	Proposed
Avg Time	23.76 ms	10.34 ms	17.93 ms	37.49 ms	7.21 ms

, with the proposed method achieving the shortest single recognition time. Its computational overhead primarily originates from two stages:

(1) Singular spectrum feature extraction: Although the SVD computation grows drastically with the current sequence length, the proposed method’s lower sampling frequency (equivalent to downsampling, reducing the data points by tenfold, e.g., 50 kHz → 5 kHz corresponding to 3000 samples → 300 samples when 3 nominal cycles are adopted) results in a significantly lower operational overhead.

(2) Classification stage: When processing equivalently scaled data, the computational costs generally increase sequentially for XGBoost, SVM, BPNN, and RNN. XGBoost demonstrates substantial efficiency advantages since it only requires traversing a limited number of decision trees.

Furthermore, due to the significantly higher computational efficiency of WT compared to MLP, WT-SVM achieves faster recognition speeds than MLP-SVM.

5. Discussion

Based on the preceding experimental results, although the proposed method achieves high overall accuracy in multi-class fault arc recognition, the recognition accuracy for classes A2 and G2 is relatively lower. To investigate the underlying causes and provide directions for future research, we conducted a t-distributed Stochastic Neighbor Embedding (t-SNE) dimensionality reduction analysis on the singular spectrum statistical feature sets of fault arcs in classes A2, D2, G2, and F2, as shown in Figure 9. The visualization reveals that G2 and A2 are adjacent in the feature space with partial overlap (particularly in the central and upper-right regions), while D2 and F2 exhibit noticeable mixing in the lower and central regions. Generally, such phenomena may arise from data imbalance or quality issues, missing key discriminative features, feature redundancy, and noise interference. Since the dataset in this study is balanced and of high quality, the lower accuracy for A2 and G2 may be attributed to (i) insufficient singular spectrum feature extraction, failing to capture certain key information; (ii) redundancy in the singular spectrum and lack of noise suppression; (iii) redundancy or insufficiency in the nine statistical features; and (iv) the feature set considering only singular spectrum amplitudes without incorporating the frequency-domain distribution information. Future work will address these aspects in greater depth.

6. Conclusions

To address the insufficient identification rate of series AC fault arcs, this article proposes a novel series arc fault detection method integrating singular spectrum statistical features with an XGBoost classifier. The approach first extracts the singular spectrum statistical feature sets from current waveforms under diverse fault arc conditions. These features are then utilized as the input data for an XGBoost classifier optimized via a differential evolution algorithm, ultimately constructing an optimal arc fault identification model. The experimental results demonstrate that (1) the proposed method achieves a 98.90% success rate in identifying 16 fault scenarios using only three nominal cycles of sampling length; (2) it maintains a 97.11% recognition accuracy with merely 5% of the dataset as the training samples, showcasing exceptional generalization capability; (3) the solution operates effectively without high sampling frequencies or extended observation windows, enabling rapid response times and seamless deployment on resource-constrained embedded platforms; and (4) compared to mainstream methods (BPNN, SVM, and RNN), it outperforms by three percentage points in its overall recognition accuracy, demonstrating significant advantages.