Multi-Signal Induction Motor Broken Rotor Bar Detection Based on Merged Convolutional Neural Network

Abstract

Motor fault detection plays a vital role in industrial maintenance. Timely detection of faults in their early stages can prevent catastrophic consequences and reduce maintenance costs. Traditional methods face challenges in motor broken rotor bar (BRB) detection: model-driven methods are difficult to apply accurately in complex and changing environments, while data-driven methods usually require sophisticated feature extraction and classification processes. In this paper, we propose a novel non-invasive fault detection method. The method preprocesses motor currents by Hilbert-Huang Transform (HHT) and Park’s Vector Modulus (PVM) and then uses a merged convolutional neural network (CNN) for classification. This experiment investigates the detection of broken rotor bars of motors with different loads (25%, 50%, 75%, and 100% of rated load) and different fault levels (Normal, 1BRB, 2BRB, 3BRB, and 4BRB). The results show that the model’s classification accuracy exceeds 95% under various operating conditions and can maintain high accuracy under low load conditions, thus addressing the limitations faced by existing methods. In addition, it is computationally efficient and can guarantee high real-time performance. This method combines advanced signal processing techniques and deep learning algorithms to provide a practical solution for motor broken rotor bar detection.

1. Introduction

Industrial motors are a fundamental part of modern production systems. The reliability of them has a direct impact on productivity and operational costs. Three-phase induction motors are more commonly used in industrial production, comprising about 70% of all industrial motors [1]. Regarding energy consumption, it is estimated that more than 50% of the electricity produced globally is used in motors, with induction motors accounting for about 60% of the industrial electrical load [2].

There is a wide range of motor faults, including electrical faults, such as stator faults [3] and broken rotor bars [4], as well as mechanical faults, such as bearing faults [5] and air gap eccentricity [6]. According to an IEEE report [7], about 10% of motor faults are rotor-related.

Many factors can lead to broken rotor bars in large industrial induction motors with copper cages. The main causes are corrosion, vibration, and the thermal expansion of the rotor bars in the axial direction [8]. During motor operation, the rotor is subjected to various stresses from thermal, mechanical, dynamic, and magnetic fields [9,10,11], which act together to cause rotor faults.

In recent decades, motor fault detection methods have developed significantly. They have transitioned from model-driven methods to data-driven methods. Model-driven methods focus on building a mathematical model of a motor based on physical laws and expertise and comparing its expected behavior with actual measured data to identify anomalies [12]. However, such models have major limitations: they are usually device-specific and difficult to adapt to changing operating conditions or new types of faults [13]. These disadvantages limit the widespread use of this approach.

With the advancement of signal processing techniques, data-driven methods have emerged. These methods learn patterns of normal and faulty behaviors directly from historical data to achieve stronger fault detection performance, are highly adaptable to different operating conditions, and can be extended to different types of motors [14]. Among all data-driven methods, motor current signature analysis (MCSA) stands out for its non-invasive nature [15]. In contrast to vibration, thermal, and oil sensors, electrical sensors are typically installed in the motor control cabinet rather than the asset itself, resulting in a safer installation and better protection against operational hazards.

However, early MCSA methods that detect faults by comparing the frequency spectrum of the motor current as it operates to that of the motor’s healthy working state face significant challenges. The accuracy of such methods is easily affected by load variations. It has been shown that, under low load conditions, fault eigenfrequencies become less pronounced [16], which can lead to reduced detection accuracy, and, in some cases, certain faults can only be detected above a certain load level.

To address these challenges, some researchers have used filtering methods [17,18], spectrum subtraction [19], and mathematical morphology [20,21] to preprocess current signals and enhance fault characteristics in the frequency spectrum. However, these methods still cannot completely remove the influence of noise, and some can distort the original data and obscure genuine fault signals. Others have explored time–frequency analysis techniques, such as wavelet transform [22], wavelet packet decomposition (WPD) [23], and MCSA-based Wigner-Ville distribution (WVD) [24]. While these methods can improve feature extraction capabilities, they require extensive parameter tuning, limiting their transferability across different motors. Furthermore, some methods have high computational complexity, which reduces the efficiency of fault detection.

Nonparametric demodulation transformation methods were proposed to overcome these limitations. Classic methods include Park’s Vector Analysis (PVA) [25], Hilbert transformation [26,27], and Teager-Kaiser energy operator (TKEO) [28]. These methods can decompose the original current signal into multiple components, including power fundamental waves, fault harmonics, and environmental noise, thereby highlighting fault features. The disadvantage is that their standalone use often struggles to distinguish similar fault frequencies.

In the traditional MCSA techniques mentioned above, after feature extraction, fault classification is usually performed using manual or rule-based decision-making, which relies on expert knowledge of the fault characteristics. The success of fault detection depends on selecting appropriate features that are both sensitive to faults and robust to noise and operational variability. Artificial Intelligence (AI) methods can solve the problem of the over-complexity of traditional classifiers through model training. AI methods can be divided into two main categories: shallow learning and deep learning. Typical shallow learning methods include fuzzy logic (FL) [29], multi-layer perceptron (MLP) [30], random forest (RF) [31], support vector machine (SVM) [32,33,34], and decision tree (DT) [35]. However, these methods require prior knowledge for manual feature engineering, with classification accuracy suffering without proper preprocessing [15].

Deep learning (DL) methods can automatically learn hierarchical features of input data without the need for manual feature engineering, thus enabling efficient classification of preprocessed signals. Current research includes the convolutional neural network (CNN) [36,37], deep belief network (DBN) [38], autoencoder (AE) [39], generative adversarial network (GAN) [40], and Kolmogorov-Arnold Network (KAN) [41,42]. While some studies have applied one-dimensional CNNs (1D CNNs) directly to raw current signals [43,44], eliminating the need for signal preprocessing, this approach can struggle with complex noise patterns and load variations that are common in industrial settings. In addition, cognitive computing is a more novel approach, and related research can be found in references [45,46].

In this paper, we propose a data-driven approach that hybridizes signal processing techniques with deep learning. We first preprocess the motor current data through HHT and PVM to generate images, which are divided into two labels: Normal and BRB. Then, we use the labeled data to train a merged convolutional neural network for fault classification. We combine the advantages of nonparametric data processing methods and deep learning algorithms to provide a new approach to broken rotor bar detection.

The main contributions of this paper can be summarized in four areas:

• A non-invasive, data-driven method for broken rotor bar detection is investigated. The method is based on motor currents, does not require invasive sensors, and has a straightforward, practical architecture.
• The adaptive demodulation transformation method is used for data preprocessing, without complex parameter adjustment. A deep neural network is used as a classifier for fault classification, without manual feature engineering.
• We demonstrated the robustness of the methodology through comprehensive experimental validation at multiple load levels (25%, 50%, 75%, and 100%) and fault levels (normal and 1-4 broken rotor bars).
• The metrics to evaluate the computational efficiency of the model training and testing procedures are calculated to demonstrate its real-time performance.

The rest of this paper is organized as follows: Section 2 introduces the theoretical basis of the proposed method. Section 3 introduces the method in detail, including signal preprocessing and CNN architecture. Section 4 introduces the experimental setup and model testing process, presents the experimental results, and discusses them. Finally, Section 5 concludes this paper and proposes future research directions.

2. Theoretical Foundation

2.1. Principles of BRB and MCSA

2.1.1. Physical Structure and Fault Mechanism

The squirrel cage rotor consists of conductive bars which are connected by end rings at each end. During normal operation, the conductive bars carry an induced current that interacts with the rotating magnetic field of the stator to produce torque. The rotor bars are subjected to a variety of stresses generated by thermal, mechanical, and magnetic fields as well as load variations during operation.

A broken rotor bar causes discontinuity in the current path through the rotor cage, which, in turn, leads to redistribution of the current between neighboring bars of the broken rotor bar, resulting in an asymmetrical current pattern in the rotor [47]. Increased current densities in neighboring conductive bars can cause that section to heat up and accelerate its degradation. If the initial fault goes undetected, it can lead to cascading faults.

2.1.2. Electromagnetic Field Effects

A broken rotor bar affects the motor air gap magnetic field in two ways. First, the redistribution of local currents produces an asymmetric magnetic field distribution in the air gap [48,49]. This asymmetry modulates the base magnetic field of the motor as the rotor rotates. The depth of modulation is related to the severity of the fault, with multiple broken bars producing a stronger modulation effect.

Second, an asymmetric current distribution leads to a magnetic imbalance. This imbalance leads to torque pulsations twice the slip rate [50]. The torque pulsation component introduces velocity fluctuations, which, in turn, produce additional modulation of the air gap magnetic field.

2.1.3. Motor Current Signature

A broken rotor bar produces characteristic sidebands on the motor current spectrum. The sidebands are categorized into two types as follows.

1.

Primary Sidebands:

The primary sidebands are given by $\left(1\pm 2s\right)f_s$, where $f_s$ is the supply frequency and $s$ is the slip. The lower sideband $\left(1-2s\right)f_s$ represents the counterrotating magnetic field component, and the upper sideband $\left(1+2s\right)f_s$ is caused by speed oscillation [51].

2.

Higher Order Sidebands:

Due to the spatial distribution of the magnetic field and the periodic nature of the fault, the mathematical relationship between slip $s$ and sideband frequencies $f_{sb}$ can be expressed through the general formula [15]:

$$f_{sb}=\left(1\pm 2ks\right)f_s k=1,2,3\dots$$

(1)

A motor with broken rotor bars will produce a current with abnormal sideband frequencies. Data preprocessing can transform the raw current data into more meaningful fault classification information. After proper preprocessing of the current, we can highlight the features that distinguish between a normal motor and a faulty motor.

2.2. Hilbert-Huang Transform

Hilbert-Huang Transform (HHT) is a data processing method that combines time–frequency analysis and demodulation transformation. It provides a data-driven approach to analyzing nonlinear and non-stationary signals. This method is adaptive and does not require basis functions like traditional time–frequency analysis methods.

2.2.1. Empirical Mode Decomposition

The HHT begins with Empirical Mode Decomposition (EMD) [52], which adaptively decomposes a signal into Intrinsic Mode Functions (IMFs). Each IMF must satisfy two conditions: the number of extrema and zero crossings must either be equal or differ at most by one; the mean value of the envelope defined by local maxima and local minima must be zero.

The EMD process follows these steps [53]:

• Initialization:

Set the initial residual $r_0\left(t\right)=x\left(t\right)$ and the iteration counter $i=1$.

2.

Extrema Identification:

Identify all local maxima and minima of the current residual $r_{i-1}\left(t\right)$.

3.

Envelope Generation:

Create an upper envelope $e_{max}\left(t\right)$ by interpolating between the local maxima using a cubic spline.

Create a lower envelope $e_{min}\left(t\right)$ by interpolating between the local minima using a cubic spline.

4.

Mean Envelope Calculation:

Calculate the mean envelope $m_{i-1}\left(t\right)$ as the average of the upper and lower envelopes:

$$m_{i-1}\left(t\right)={\displaystyle \frac{e_{max}\left(t\right)+e_{min}\left(t\right)}{2}}$$

(2)

5.

Detail Extraction:

Subtract the mean envelope from the current residual to obtain a candidate IMF $h_{i-1,k}\left(t\right)$:

$$h_{i-1,k}\left(t\right)=r_{i-1}\left(t\right)-m_{i-1}\left(t\right)$$

(3)

where k is the inner iteration counter, initialized to 1 for each new IMF.

6.

IMF Check (Inner Loop):

Check if $h_{i-1,k}\left(t\right)$ satisfies the IMF conditions.

If $h_{i-1,k}\left(t\right)$ satisfies the conditions, it is considered an IMF. Proceed to step 7.

If $h_{i-1,k}\left(t\right)$ does not satisfy the conditions, increment $k \left(k=k+1\right)$, set $r_{i-1}\left(t\right)=h_{i-1,k-1}\left(t\right)$, and repeat steps 2–5 (inner loop). This inner loop sifts $h$ until it meets the IMF criteria. A common stopping criterion for this inner loop is to ensure that the standard deviation (SD) between successive sifting results, calculated as follows, is below a predefined threshold (usually between 0.2 and 0.3) [54].

$$SD=\sum _{t=0}^T{\displaystyle \frac{{\left|h_{i-1,k-1}\left(t\right)-h_{i-1,k}\left(t\right)\right|}^2}{h_{i-1,k-1}^2\left(t\right)}}$$

(4)

7.

IMF Extraction and Residual Update:

Once an IMF, $c_i\left(t\right)$, is found (i.e., $h_{i-1,k}\left(t\right)$ becomes an IMF), store it:

$${c_i\left(t\right)=h}_{i-1,k}\left(t\right)$$

(5)

Update the residual:

$$r_i\left(t\right)=r_{i-1}\left(t\right)-c_i\left(t\right)$$

(6)

8.

Outer Loop Iteration:

Increment the IMF counter ($i=i+1$).

9.

Stopping Criterion (Outer Loop):

If the residual $r_i\left(t\right)$ becomes monotonic or if the number of IMFs reaches a predefined limit, the decomposition is complete.

Otherwise, set $r_{i-1}\left(t\right)=r_i\left(t\right)$ and return to step 2.

The EMD process results in a decomposition of the original signal $x\left(t\right)$ into $n$ IMFs, $c_i\left(t\right)$, and a final residual, $r_n\left(t\right)$:

$$x\left(t\right)=\sum _{i=1}^n{c}_i\left(t\right)+r_n\left(t\right)$$

(7)

where $r_n\left(t\right)$ represents the overall trend of the signal. The IMFs are nearly orthogonal and represent different oscillatory modes embedded in the original signal, ordered from high frequency to low frequency.

2.2.2. Hilbert Transform and Instantaneous Frequency

After obtaining IMFs, perform Hilbert transform on each IMF. For an IMF x(t), its Hilbert transform y(t) is as follows:

$$y\left(t\right)={\displaystyle \frac{1}{\pi }}P.V.{\int }_{-\mathrm{\infty }}^{\mathrm{\infty }}{\displaystyle \frac{x\left(\tau \right)}{t-\tau }}d\tau$$

(8)

where the P.V. refers to the principal value, which handles the singularity at $\tau =t$ in the integrand.

The analytic signal z(t) is then formed:

$$z\left(t\right)=x\left(t\right)+jy\left(t\right)=A\left(t\right)e^{j\theta \left(t\right)}$$

(9)

where A(t) is instantaneous amplitude and θ(t) is the instantaneous phase.

The instantaneous frequency is calculated as follows:

$$f\left(t\right)={\displaystyle \frac{1}{2\pi }}{\displaystyle \frac{d\theta \left(t\right)}{dt}}$$

(10)

Finally, different colors are used to represent the instantaneous frequency of each IMF at each moment to generate the HHT spectrum.

Figure 1a shows all the IMFs generated by a current signal after EMD, and Figure 1b is the HHT spectrum generated by IMF after Hilbert transform. The horizontal axis represents time (from 0 to 0.167 s), and the vertical axis represents the IMF index (from 0 to 8), where lower indexes correspond to high-frequency components and higher indexes correspond to low-frequency components. The color intensity follows the logarithmic frequency distribution law, representing the instantaneous frequency corresponding to the horizontal axis time, red for high frequency and blue for low frequency. This color distribution pattern can better highlight the fault characteristic frequencies with smaller amplitudes.

2.2.3. Computer Algorithm for Calculating the Analytic Signal

When using a computer to calculate the Hilbert transform, to improve the calculation efficiency, the following algorithm is used for calculating the analytic signal z(t):

• x ← array(x)
• X_f ← fft(x)
• h ← zeros
• if N%2 = 0 then:
  h[0], h[N/2] ← 1, 1
  h[1:N/2] ← 2
• else: h[0]←1; h[1:(N + 1)/2] ← 2
• z ← ifft(X_f⋅h, axis)
• return z

where x is the input real-valued signal, which needs to be converted to an array, fft is fast Fourier transform, and ifft is inverse Fourier transform. N defaults to the length of the input signal, and axis defaults to −1. For more details, please refer to [55].

2.3. Park’s Vector Analysis

Park’s Vector Analysis (PVA) is a classical demodulation transformation method that converts three-phase currents ($i_a$, $i_b$, $i_c$) into a two-dimensional vector ($i_d$, $i_q$) [56]. This method is well suited for steady state analysis as it demodulates the modulated current of a faulty motor, removes the fundamental component, and highlights the fault features for effective fault detection. Park’s transform is given by the following equations:

$$i_d={\displaystyle \frac{2}{3}}\mathrm{ }\left(i_a-{\displaystyle \frac{1}{2}}\mathrm{ }{i}_b-{\displaystyle \frac{1}{2}}\mathrm{ }{i}_c\right)$$

(11)

$$i_q={\displaystyle \frac{1}{\sqrt{3}}}\left(i_b-i_c\right)$$

(12)

The PVM is the modulus of Park’s vector and is given by the following equation:

$$PVM=\sqrt{i_d^2+i_q^2}$$

(13)

The ordinary PVA image is the trajectory of the point ($i_d$, $i_q$) in the coordinate system, which is close to a hexagonal pattern, while the PVM image has the motor current sampling points on the horizontal axis and the corresponding PVM values on the vertical axis. As shown in Figure 2, the PVA images of normal and faulty motors show slight geometric differences, while the PVM images show more obvious differences in oscillation characteristics, which are easier to capture with deep learning models.

2.4. Convolutional Neural Network Architecture

2.4.1. Convolutional Layer

Convolutional layer is the basic structure of CNN, performing feature extraction through kernels sliding across input data. For an input feature map x and kernel w, the convolution operation at position $\left(i,j\right)$ is computed as follows:

$$y\left(i,j\right)=\sum _{m=0}^{k-1}\sum _{n=0}^{k-1}x\left(i+m,j+n\right)\cdot w\left(m,n\right)+b$$

(14)

where $k$ is the kernel size, $x\left(i+m,j+n\right)$ is the value of the input feature map at position $\left(i+m,j+n\right)$, $w\left(m,n\right)$ is the kernel at position $\left(m,n\right)$, and $b$ is the bias term. Multiple kernels of the CNN run in parallel to learn different feature representations. Each kernel is specialized to detect specific patterns such as edges and textures. The size of the output feature map is determined by the kernel size, stride $s$, and padding parameter $p$, which is computed as follows:

$$\mathrm{output} \mathrm{size}={\displaystyle \frac{\mathrm{input} \mathrm{size}-k+2p}{s}}+1$$

(15)

2.4.2. Pooling Layer

Pooling layers reduce spatial dimensions while retaining important features through downsampling [57]. The merged CNN proposed in this paper adopts max pooling, which outputs the maximum value within a sliding window:

$$y\left(i,j\right)=\mathit{max}\left\{x\left(i+m,j+n\right)\right\} 0\le m<h,0\le n<w$$

(16)

where $h$ and $w$ define the pooling window size. Pooling contributes to achieving translation invariance by decreasing feature map dimensions while preserving dominant features. Reducing dimensionality helps prevent overfitting, improve model generalization, and lower computational complexity.

2.4.3. Fully Connected Layer

The fully connected layer receives flattened feature maps and performs high-level reasoning through dense connections [57]. Each neuron connects to all neurons in the previous layer, computing the following:

$$y_i=\sum _{j=1}^n{w}_{ij}\cdot x_j+b_i$$

(17)

where $w_{ij}$ represents the connection weight between the $j$-th neuron in the previous layer and the $i$-th neuron in the current layer, $x_j$ is the output from the $j$-th neuron of the previous layer, and $b_i$ is the bias term for the $i$-th neuron in the current layer.

2.4.4. Mish Activation Function

Mish activation provides smooth, non-monotonic behavior beneficial for deep networks [58], defined as follows:

$$Mish\left(x\right)=x\cdot \mathit{tanh}\left(\mathit{ln}\left(1+{\mathrm{e}}^x\right)\right)$$

(18)

This self-regularizing function has the advantages of zero centering, unbounded positive values, and bounded negative values. Its smoothness helps the gradient flow during back-propagation, allowing better information flow than the traditional ReLU activation function, which is especially beneficial for deep architectures.

2.4.5. Model Training Process

Training optimizes network parameters through backpropagation using categorical cross-entropy loss:

$$L=-\sum _{i=1}^C{y}_{\mathrm{true},i}\cdot \mathit{log}\left(y_{\mathrm{pred},i}\right)$$

(19)

where $C$ is the number of classes, $y_{\mathrm{true},i}$ is the true probability distribution (usually 1 for the correct class, 0 for others), and $y_{pred,i}$ is the predicted probability distribution from the network.

The Adaptive Moment Estimation (Adam) optimizer [59] adjusts parameters using adaptive learning rates:

$${\theta }_{t+1}={\theta }_t-\alpha \cdot {\displaystyle \frac{\widehat{m_t}}{\sqrt{\widehat{v_t}}+ϵ}}$$

(20)

where ${\theta }_t$ is the parameter at time step $t$, $\alpha$ is the learning rate, $\widehat{m_t}$ and $\widehat{v_t}$ are bias-corrected moment estimates for the first and second moments of the gradients, and $ϵ$ is a small constant to prevent division by zero.

2.4.6. Merged Model Architecture

The merged architecture combines parallel convolutional neural networks (streams), processes multiple inputs, and fuses their features before the final classification [60].

Let $F_1$ represent the final feature map tensor produced by the HHT processing stream before flattening, and $F_2$ represent the final feature map tensor from the PVM stream. These feature map tensors are first flattened into one-dimensional vectors: $v_1=flatten\left(F_1\right)$; $v_2=flatten\left(F_2\right)$

The $flatten\left(\right)$ operation reshapes the tensors into vectors by concatenating their elements. These flattened vectors are then concatenated to create a single, combined feature vector, $v_{combined}=\left[v_1;v_2\right]$, where $[;]$ denotes concatenation. $v_{combined}$ is then used as the input to the first fully connected layer, as described in Section 2.4.3.

3. Proposed Methodology

3.1. Data Collection and Segmentation

The experiment collects current signals in a total of 20 different operating states on a real industrial motor (For the motor dataset, please refer to the website https://new.abb.com/cn/innovation/2024-abb-cup-innovation-contest/MO-contest, accessed on 2 January 2025): normal operation and four levels of broken rotor bar faults (1–4 BRB) combined with four different loads (25%, 50%, 75%, and 100% of rated load).

The motor current data used in this experiment come from real motors, not simulated data, and already contain common noise. As can be seen from Figure 3, the current waveform is not a completely smooth sine curve.

The power frequency of the motor is 60 Hz. The current sensor samples the motor current at a sampling frequency of 50,000 Hz. The motor current is sampled for 20 s in each operating state, including the motor start-up transient and the steady state. Figure 3 shows the sampled signals of the motor from start-up transient (sampling point 100,000–112,000) to steady state (sampling points after 112,000). This experiment only uses steady-state motor currents.

We use a sliding window of 8333 data points in length for data segmentation (corresponding to approximately 10 power cycles, capturing the full periodic behavior of the current signal), with a sliding step of 833 data points (approximately one power cycle). As shown in Figure 4, for normal motor current, approximately the 160,000th (about 1 s after the motor enters steady state) to 340,000th data points are used for model training, generating a total of 800 pairs of training data (will be further divided into training and validation datasets), and the data points after the 340,000th are used for model testing. For faulty motor currents, from the 160,000th to the 210,000th data points are used for model training and validation, also generating a total of 800 pairs of training data, and the data points after the 340,000th are used for model testing. All current data contain a total of approximately 1,000,000 data points. The training set is used to train the model, the validation set is used to adjust hyperparameters and monitor overfitting, and the testing set is used to finally evaluate the model performance.

3.2. Data Preprocessing

In the data preprocessing stage of the experiment, we use HHT to process single-phase current and PVM to process three-phase current. Both data processing methods are used to process the steady-state current.

In Figure 5, the HHT spectrum clearly shows the modal structure of the motor current. From this, we can distinguish the abnormal modes of faulty motors.

PVA acts as an excellent demodulator for fault-related current components. As shown in Figure 6a, the PVM shows a relatively consistent oscillation pattern, and the modulation envelope is more uniform. This is a characteristic of normal motor operation. In contrast, the PVM in Figure 6b,c show obvious differences: the oscillation range is increased overall, and the oscillation pattern has no obvious periodicity, reflecting the obvious characteristics of a faulty motor.

3.3. Deep Learning Architecture

Figure 7 shows the whole process of model training. The process first acquires and segments data and then preprocesses the segmented data to generate HHT and PVM images as training datasets. The training datasets consist of the following: 800 HHT plots of normal motors, 800 HHT plots of faulty motors, 800 PVM plots of normal motors, and 800 PVM plots of faulty motors. Each set contains four load levels. In the training process, the datasets are divided into two labels: Normal and BRB. In this case, 1–4 BRB are all counted as “BRB”. Both labels contain 800 HHT images and 800 PVM images, respectively. Then, we convert them into 128 × 128 grayscale images as CNN input for model training. After model training, the model parameters are saved for subsequent experiments.

The fault classifier adopts a merged CNN architecture, where each stream processes a type of signal independently, one stream processes the HHT image, and the other stream processes the PVM image. Finally, they are merged at the fully connected layer for classification.

As detailed in Figure 8, the HHT processing flow (top) receives a 128 × 128-pixel grayscale HHT image as input. First, it passes through a convolutional layer with eight feature maps, 3 × 3 kernel size, stride 1, “valid” padding (no padding), and Mish activation. The feature maps are then downsampled by a 2 × 2 max pooling layer with stride 2. This is followed by two identical convolution-pooling layer combinations: a convolutional layer with 16 3 × 3 kernels, stride 1, “valid” padding, and Mish activation; and a max pooling layer with 2 × 2 size and stride 2. After three sets of convolution and pooling operations, the feature maps are flattened into a one-dimensional vector.

The PVM processing flow (bottom) receives a 128 × 128-pixel grayscale PVM image as input. Its structure is similar to the HHT flow. Except for the first convolutional layer with a kernel size of 5 × 5, the other parameters are the same as the HHT stream.

The outputs of the two processing streams (flattened 1D vectors) are concatenated to form a feature vector containing the combined information of HHT and PVM. The feature vector is then input to a fully connected layer with 1024 neurons and a ReLU activation function. Finally, a fully connected layer with two neurons (output layer) is used to output the probability of the sample belonging to the two categories (normal or BRB) using a Softmax activation function. We use a relatively small number of feature maps and neurons in the fully connected layer to avoid overfitting. During model training, we use the Adam optimizer with a default learning rate of 0.001 and categorical cross entropy as the loss function. The training process is performed for 30 epochs with a batch size of 32. Model parameters are automatically updated through the back-propagation algorithm.

Figure 9 shows the evaluation indicators of the model training process, including accuracy and loss value. As can be seen from the figure, the model reaches convergence around the 10th training epoch, with a fast convergence speed, and maintains high accuracy and low loss value in subsequent training rounds without excessive fluctuations. Moreover, the model is not overfitted.

4. Experimental Validation

4.1. Experimental Test Results

In the experimental validation phase, we segment the testing current data obtained by the method shown in Figure 4 using non-overlapping windows to generate HHT and PVM images, which are input into the trained model for model testing. The window length is 8333 and the sliding step is also 8333. A total of 1580 samples are generated for testing.

We use the ratio of the number of correctly predicted samples (data segments) to the total number of samples as the overall accuracy of the model. The overall accuracy reaches 99.62% in the experiment. To further evaluate the model performance, we generate the classification report and confusion matrix, as shown in

Table 1. Overall classification report of model testing.

	Precision	Recall	F1-Score	Support
Normal	0.981366	1	0.990596	316
BRB	1	0.995253	0.997621	1264
Accuracy			0.996203	1580
Macro Avg	0.990683	0.997627	0.994108	1580
Weighted Avg	0.996273	0.996203	0.996216	1580

and Figure 10. We can see that the model is very accurate without overfitting. The confusion matrix visualizes the classification results, where percentages represent the proportion of samples of each true class (rows) that are classified into each predicted class (columns). These percentages are derived from the data used to calculate precision and recall in Table 1.

Table 2. Testing accuracy of all 20 working states.

	25% Load	50% Load	75% Load	100% Load
Normal	100%	100%	100%	100%
1 BRB	95.0%	97.5%	100%	100%
2 BRB	100%	100%	100%	100%
3 BRB	100%	100%	100%	100%
4 BRB	100%	100%	100%	100%

illustrates the fault detection accuracy for each of the 20 operating conditions. The results show that the model has about 3–5% incorrect prediction labels for motors with one BRB at 25% and 50% loads, mainly because the current fault characteristics of motors with smaller faults at lighter loads are not obvious enough. Except for this, the prediction accuracy for the other working states reaches 100%. In general, it can be considered that the accuracy of the model remains high under the condition of weak characteristics.

4.2. Comparative Analysis

We compare the accuracy of the proposed approach to alternative approaches to show its advantages. The comparison includes the following:

• Single-signal approaches using HHT or PVM with CNN classifiers.
• Wavelet transform-based time–frequency distribution (TFD) images with CNN classifiers.
• Various signal combination strategies in the merged CNN architecture.

All the above methods use the same parameters and training epochs. We split the previously acquired training dataset into 60% for training, 20% for validation, and 20% for testing. Each method is tested 20 times independently, each time using different random seeds for weight initialization and data shuffling. The mean test accuracy ± standard deviation of each method is listed in Table 2.

As can be seen from

Table 3. Accuracy comparison of different methods.

Method	Mean Test Accuracy ± Standard Deviation
PVM single signal	0.9875 ± 0.0069
HHT single signal	0.9616 ± 0.0181
TFD single signal	0.9880 ± 0.0072
PVM+TFD Merged	0.9975 ± 0.0029
HHT+TFD Merged	0.9936 ± 0.0115
HHT+PVM Merged	0.9980 ± 0.0030

, the accuracy of the merged model is generally higher than that of the single-signal model, mainly because the single-signal model learns the features of only one signal, while the merged model can learn the complementary features of multiple signals, which significantly improves the accuracy and stability.

TFD images are generated by the wavelet transform of the electric current signal, which needs to be adjusted for various parameters including scale, frequency range, and type of wavelet basis function. This makes the TFD method difficult to optimize and means that it may miss critical fault features. On the other hand, HHT and PVM are adaptive data processing methods that do not require parameter adjustment, are more efficient, and have stronger generalization ability. In summary, the HHT + PVM + Merged model method proposed in this paper is more practical and efficient.

4.3. Real-Time Performance Analysis

Practical applications of fault detection require not only high accuracy but also computational efficiency of the algorithm [61]. The CNN algorithms for this experiment are executed on the TensorFlow Keras platform, and all experiments are implemented on a Windows personal computer with an Intel Core i9 12th Gen. CPU.

The model training time is 59.57 s, meaning that the computational complexity is low, allowing us to train the model in about 1 min.

During model testing, for each testing motor current file, we calculate the HHT transform, PVM transform, model inference, and total pipeline times, and calculate their average, standard deviation, minimum, and maximum, as shown in

Table 4. Overall timing statistics (unit: seconds).

	Average	Standard Deviation	Minimum	Maximum
HHT Transform	12.4978	1.6806	9.6252	17.4304
PVM Transform	1.3462	0.2835	1.1206	2.1740
Model Inference	0.0746	0.0426	0.0535	0.2436
Total Pipeline	13.9296	1.8114	11.1852	18.9608

.

From the table, we can infer that the model can predict a current sample (8333 data points) within an average of 0.2 s, reflecting the high computational efficiency and the capability for real-time operation.

5. Conclusions and Future Work

This paper proposes a practical method for broken rotor bar fault detection. This method preprocesses the motor current signal through HHT and PVM, trains a merged CNN model, realizes nonparametric feature extraction and automatic fault classification, and maintains high accuracy at both low loads and small fault levels. In addition, the computational complexity of this method is low, and real-time fault detection can be achieved.

The limitation is that the research is only conducted on one motor, which makes it difficult to ensure generalization ability, and the detection of incomplete broken rotor bar faults (such as 1/2 BRB, 3/4 BRB) is not studied.

Future research directions include collecting more abundant motor current data to solve the above problems, improving the detection accuracy of weak features through denoising methods and tuning the network architecture, extending this method to the detection of multiple faults, and solving the problem of limited training data through data enhancement methods. In addition, pre-trained models can be studied to improve generalization capabilities.