Open Gate, Open Switch and Short Circuit Fault Detection of Three-Phase Inverter Switches in Induction Motor Drive Applications

Abstract

Electric motor drives with a wide variety of applications are usually derived with inverters, where the inverter switches are always prone to different types of faults. Short circuit faults can rapidly shut down systems, and open-circuit ones can lead to secondary damage if they are not detected and tolerated in time. Due to this fact, in this paper, a novel data-driven fault detection and diagnosis (FDD) method has been proposed to detect and locate all types of inverter switch faults. Three deep learning algorithms, including fully connected neural networks (FCNs), convolutional neural networks (CNNs), and bidirectional long short-term memory (BiLSTM), have been implemented and compared. The BiLSTM network with 98.45% accuracy outperforms the others and can detect all types of faults in less than half a fundamental period under different and variable speeds with the existence of noise. The results show that the proposed method is highly effective and is a great candidate for real-time applications.

1. Introduction

Induction motors have become integral to a wide range of industrial applications, notably serving as the primary traction machines in electric vehicles (EVs). The outstanding role of power inverters that convert DC bus voltage into the required AC waveforms for motor drives and distributed energy resources cannot be ignored [1,2,3]. Within these inverters, semiconductor switching elements show a critical vulnerability, accounting for approximately 38% of all driver-circuit failures [4].

Possible faults in these switches can be predominantly categorized as open-circuit (OC) or short-circuit (SC) conditions. OC faults, which often result from a lost gate-driver signal, a disrupted connection, environmental situations, etc. [5], do not immediately stop the drive; however, they induce uneven current paths and elevated thermal stress on adjacent components, thereby accelerating aging and resulting in secondary damage [6]. SC faults—triggered by over-voltage transients, thermal overstress, protective-device malfunctions, or erroneous gate signals—can generate runaway currents that instantly affect system operation and risk catastrophic damage [7]. Both fault types can lead to unwanted effects, such as torque ripple, efficiency degradation, unplanned shutdowns, and even safety hazards. Consequently, the development of robust fault detection and diagnosis (FDD) strategies is essential for maintaining the reliability and safety of EV drive systems [8].

FDD techniques for inverter systems are typically classified into model-based, signal-based, and data-driven approaches [9]. Model-based methods rely on accurate mathematical representations of the drive to generate residuals, with deviations between predicted and measured values serving as fault indicators. Signal-based techniques extract diagnostic features, whether in the time, frequency, or time--frequency domain, from measured waveforms and apply threshold-based decision rules to detect anomalies.

In the past years, various model- and signal-based techniques for fault detection have been introduced. An observer was designed to estimate the currents, and by comparing its output with the measured values, residuals were generated [10]. Then, to increase the accuracy and reliability, the average of the residuals was compared to a designed adaptive threshold to reveal OC faults. Kalman filters (KFs) were used to estimate three phase currents, and the residuals were derived by comparing the estimated values to the measured ones [11]. The normalized averaged residuals were used as the OC fault indicators. A mixed logic dynamic (MLD) model was used to estimate the current in [12]. The current residual vector (CRV) is analyzed to detect OC faults. Three phase current distortions due to OC faults were estimated and compared to a threshold to detect OC faults in vector-controlled induction motor drive [13]. A differential current observer was used to generate the residual, and an adaptive threshold was employed to detect OC faults in various motor operating conditions, as reported in [14]. The calculated common-mode voltage of the inverter was compared to the measured values to indicate and locate the OC faults in the induction motor drive [15]. Recently, model predictive control (MPC) has gained more attention and has been used more often. MPC was used to only detect open-switch (OS) faults in an induction motor drive based on voltage means and their polarities [16]. However, it relies on threshold values.

As signal-based techniques, in [17], normalized line-to-line currents were used to detect the OC faulty leg, and then, by considering the current polarity of the faulty phase, the exact faulty switch was detected. In [18], three fault indicators were derived using three-phase currents and their Clarke transform. The deviations in these parameters were compared to the tuned threshold to detect single OC faults. The introduced method needs threshold tuning and only considers the transistor fault and not the diode. Two phase current measured values and the sum of the absolute normalized phase current were used to generate fault indicators [19]. Zero-cross detection was utilized to immune the FDD against transient conditions. By comparing the fault indicator to the thresholds, it was used to detect OC faults. For SC fault detection, the voltage space pattern of the output phase voltages was monitored along with the command signals [20]. Time–frequency distribution (TFD) monitoring is another approach to detect SC faults within the inverter [21,22]. In this method, various parameters, including average and RMS values, total harmonic distortion (THD), total waveform distortion (TWD), etc., are monitored to find any alternation as an SC fault indicator.

Both approaches demand expert knowledge and may have affected performance under complex, nonlinear, or nonstationary operating conditions. They also have limitations when it comes to generalizing to other systems.

In contrast, data-driven FDD methods leverage historical and real-time datasets to learn discriminative fault patterns without explicit physical models, thereby offering greater adaptability to system variations.

Table 1. Summary of FDD categories.

Type	Basis	Features
Model-based	Using analytical or mathematical models with estimated parameters to detect deviations	Effective for simple, well-defined systems Low computational cost and fast response Modeling nonlinear or complex drives is challenging Sensitive to load and parameter variations Requires prior knowledge and accurate models
Signal-based	Using measured signals and signal-processing techniques to extract fault signatures	Easy to implement Applicable to various operating conditions May require additional hardware Often depends on threshold tuning May degrade under noise or transient disturbances
Data-driven	Learning fault-related patterns directly from historical or labeled data	No physical model required Handles nonlinear and complex systems well Strong generalization capability High accuracy, even for early-stage faults Performance depends on quality and diversity of training data

provides a comparison between different FDD techniques. Initial implementations employed fuzzy logic and classical machine learning classifiers such as decision trees and support vector machines (SVMs). More recently, deep learning architectures, including deep neural networks (DNNs), convolutional neural networks (CNNs), recurrent neural networks (RNNs), and long short-term memory (LSTM) networks, have demonstrated the ability to automatically extract multi-scale features directly from raw sensor data, removing manual pre-processing steps and reducing detection latency. A comparison of different FDD methods is included in Table 1.

Fuzzy logic was used to analyze the fault features derived from the average current Park vector, revealing and locating OC faults [23]. A Pyramid-like deep ANN model was introduced [24]. Ten features were extracted from three-phase currents and were used to detect the single- and double-switch open-circuit fault of inverters in motor drive applications. The fault detection accuracy could reach up to 95%; however, it was only able to detect a single type of OC faults. Another deep neural network fault detection method was presented based on track and hunt optimization [25]. It was reliable under load-varying conditions, and a high accuracy of 95.73% was achieved, with the method being able to detect single-switch OC faults.

Normalized current vector trajectory graphs using the discrete wavelet transform (DWT) were combined with a CNN to detect OC fault in motor drives [26]. However, it has a high diagnostic time. A CNN model was developed and trained using fault features extracted from a combination of Park transforms and fast Fourier transforms (FFTs) [27]. This fault detection method could achieve a high accuracy of 98.75% for detecting IGBT OC faults and current sensor faults, and it took about 30ms to detect and locate the faults.

A CNN-LSTM algorithm trained based on phase-to-phase voltage was used to detect OC faults in the inverter of a three-phase motor, where three separate neural networks were deployed for each phase to increase accuracy [28]. Variational mode decomposition (VMD) was combined with a hybrid CNN-LSTM for IGBT OC fault detection [29]. While it was able to detect multiple and single IGBT faults, the accuracy was 88% and was limited to OC faults. CNN-LSTM is also being used for various industrial fault detection [30,31,32]. In [33], a method for detecting multiple OC faults was proposed, based on the sigmoid transformation of a stator current and a BiLSTM algorithm, which achieves an accuracy of 98.08%. An optimized CNN model using an adaptive sparse attention wavelet network (ASAWN) could reach a very high accuracy of 99.62%, which can detect IGBT OC faults for single- and double-switch failures [34].

OC fault detection has been widely investigated in this field [35,36]; however, most of the work carried out only focuses on one type of OC faults, mainly open gate (OG) and some other open switch (OS), and they cannot distinguish between the type of OC fault in terms of whether it is OS or OG. On the other hand, SC fault detection has received less attention. In [5], the average and RMS ratio of the currents were used as the input of an ensemble bagged tree classifier to detect single OS and gate drive malfunction. However, it does not have the capability of detecting SC faults. An LSTM-based FDD method was proposed in [37], where OS and SC faults could be detected with a high accuracy. However, this method is limited to three classes of healthy, OS and SC, which cannot locate the faulty switch. An iterative algorithm was proposed in [38] to detect SC and OC faults in a two-level inverter. By applying a voltage vector and gate signal to switches and comparing the current information to a look-up table, the fault can be revealed. This method is limited offline applications and takes 1.5 s to detect the fault.

Considering the literature review, it can be found that most of the works carried out for inverter switch fault detection are on OC faults, where they have not distinguished between just the IGBT fault (mostly open gate) or the whole switch fault (both IGBT and the diode). Furthermore, the SC faults have received less attention, and they only rely on protection circuits in the case of SC to shut down the system. To overcome this limitation, a novel, highly accurate, robust, and fast data-driven FDD technique is proposed in this paper for electric motor drive applications. Unlike the aforementioned techniques, the proposed method can detect and locate OS, OG, and SC faults in an inverter of a V/F-controlled induction motor. A BiLSTM neural network is trained to capture the temporal dependencies of the data, and it can detect, diagnose, and locate faults in less than half a fundamental period. The proposed method is robust to varying speed conditions and different speed levels. To achieve optimal performance, three different deep learning algorithms, including FCN, CNN, and BiLSTM, were implemented, and the results confirm the BiLSTM model’s superior performance. In summary, the contributions are as follows:

• Introducing a robust, high-speed fault detection and diagnosis (FDD) technique based on deep learning, specifically a BiLSTM model.
• Comprehensive fault detection and localization of OG, OS, and SC faults in less than half a fundamental cycle, enabling real-time application.
• Consistent performance under different and varying motor speeds.
• Robust to white and spike noise.
• Evaluation and comparison of three architectures (FCN, CNN, and BiLSTM), showing the BiLSTM’s superior accuracy and fault localization capability.

The rest of the paper is organized as introducing three-phase inverter faults in the next section. Section 3 presents the proposed deep learning algorithms. The results are presented in Section 4 and discussed in Section 5. Finally, the conclusion summarizes the proposed method and its outcomes.

2. Three-Phase Inverter Faults

In normal inverter operation, the modulation scheme directs conduction through one semiconductor switch per phase leg based on gate command signals, producing a near-ideal sinusoidal output current. However, exposure to variable operating stresses, device aging, and environmental factors makes these switches susceptible to malfunction. When a switch fault occurs, whether an OC or SC condition, it disrupts the symmetry of the current waveform, inducing torque and speed ripple, degrading overall performance, and potentially propagating damage to other drive-train components. Inverter switch faults can be OC or SC, where OC can only be a gate malfunction or the whole switch’s open fault, including the switch’s parallel diode.

In the event of a single-switch SC fault (Figure 1a), the switch effectively behaves as a permanent short across its terminals, resulting in severe waveform distortion, elevated RMS currents, and the risk of DC-link overcurrent. For an open-gate (OG) fault (for example, in S1), where the gate driver can no longer turn the IGBT on but the antiparallel diode remains intact (Figure 1b), only the negative half-cycle conducts (through the diode). The positive half-cycle is entirely missing; the other phases’ currents increase, and there would be a pronounced downward DC offset. Finally, if both the switch and its parallel diode fail as open (a true open-switch fault presented in Figure 1c), no conduction path exists in either direction. The phase current in the faulty leg vanishes; the remaining two phases pick up the extra load, raising their amplitudes and introducing DC-offset shifts in their waveforms. In the case of a single-switch fault, all of the above-mentioned faults might occur in one of the six switches, resulting in 18 different possible fault conditions.

Although the three-phase inverter is structurally symmetric, faults occurring on different switches of the same leg are electrically distinct. Faults on upper and lower switches of the same limb alter the available current conduction paths differently and affect different portions of the electrical cycle due to the DC-link polarity and current direction, resulting in different patterns of current imbalance. Distinguishing faults by their physical switch location is essential for accurate fault localization, targeted protection actions, and maintenance decisions. Therefore, they are treated as distinct fault types in this study.

3. Proposed FDD Method

A detailed MATLAB/Simulink (2024a) model of a 460 V, 5 HP induction motor drive under V/F control was constructed (Figure 2). A carrier-based PWM at 10 kHz was used to gate the six IGBT devices (one upper and one lower switch per phase).

To characterize the inverter’s response under every single-switch fault mode, each of the six switches was, in turn, subjected to the following:

True Open Switch (OS): Both the IGBT and its antiparallel diode are disabled, blocking all current in that phase leg.

Open Gate (OG): The IGBT channel cannot turn on, but the antiparallel diode remains intact, allowing only the negative half-cycle to conduct.

Short Circuit (SC): The switch and diode conduct continuously, effectively shorting the leg in both half-cycles.

This procedure yielded 18 distinct fault conditions plus the healthy baseline (19 classes in total, which are labeled according

Table 2. Fault labeling for each fault type and faulty switch.

OG		SC		OS
Faulty Switch	Label #	Faulty Switch	Label #	Faulty Switch	Label #
Healthy	0	Healthy	0	Healthy	0
S1	1	S1	7	S1	13
S2	2	S2	8	S2	14
S3	3	S3	9	S3	15
S4	4	S4	10	S4	16
S5	5	S5	11	S5	17
S6	6	S6	12	S6	18

). Each simulation ran for 2.5 s at a constant speed: the first 0.5 s recorded steady-state, healthy operations, and then, a fault was introduced for the remaining 2.0 s to capture the transition and faulty condition. During each run, three-phase currents and voltages were sampled at a rate of 10 kHz. RMS magnitudes over a sliding window equal to one fundamental cycle and phase angles were calculated, producing 12 scalar inputs per timestamp (three phases × [RMS, angle] × 2 variables). Therefore, each dataset used in this study consists of 25,000 samples, where the initial segment corresponds to healthy operation and the remaining samples represent a specific fault condition.

The RMS values were calculated over sliding windows of one fundamental cycle, with major overlap with the previous window. A high-overlap sliding strategy was employed with a step size of 0.1 ms between consecutive windows. This technique improves the temporal resolution of the RMS feature, allowing faster fault detection while benefiting from the RMS feature of immunity to noise and disturbances due to its averaging nature. Although the training data in this study are collected from simulated waveforms, real-world current and voltage signals are often affected by electromagnetic noise, sensor nonlinearity, and switching transients. Using RMS can improve robustness against noise compared to using instantaneous values, which contain valuable information.

To ensure adequate class representation, an equal number of samples was selected for each class, with the healthy class containing more samples than the individual fault classes. This reflects practical operating conditions, where healthy operation dominates system behavior, and it allows us to find temporal dependencies during the transition from a healthy state to a faulty state for each class. Each dataset has 25,000 samples, where the fault class is represented by a sufficiently large number of samples (20,000), enabling reliable training and evaluation. Training and testing data were generated using an independent 70/30 split (70% for training and 30% for testing) within each class, giving a total sample of 142,500 for the test (7500 for each class), and no class-weighting or data augmentation techniques were used. Prior to network training, all input features were standardized using z-score normalization to maintain consistent scaling across variables. The normalization parameters, including the mean and standard deviation, were calculated using the training dataset only and applied to the testing data to avoid information leakage. These normalized, labeled, and split datasets were used with three deep learning classifiers (FCN, CNN, and BiLSTM). Hyperparameters were tuned to balance detection speed against classification accuracy, and performance was evaluated in terms of overall accuracy, per-class recall and precision, and detection latency.

3.1. Proposed Fully Connected Deep Neural Network (FCN)

An initial fault classification network was implemented as a fully connected deep neural network (FCN). Its backbone consisted of three sequential hidden layers, each comprising dense neurons with rectified linear unit (ReLU) activations. Each layer has a linear transformation followed by the ReLU activation function as follows:

$$z^{\left(l\right)}=W^{\left(l\right)}{a}^{(l-1)}+b^{\left(l\right)}$$

(1)

$$a^{\left(l\right)}=\mathrm{ReLU}\left(z^{\left(l\right)}\right)=max\left(0,z^{\left(l\right)}\right)$$

(2)

where $a^{(l-1)}$ is the activation output from layer l, $W^{\left(l\right)}$ is the weight matrix of layer l, and $b^{\left(l\right)}$ is the bias vector of layer l. To promote stable and efficient learning, a batch normalization step preceded each hidden layer, and dropout regularization ($p=0.3$) was applied immediately afterward to prevent overfitting. The output stage was mapped into 19 units, 1 per fault or healthy class, and a softmax activation was used to yield class probabilities.

$$\widehat{y}=\mathrm{softmax}\left(W^{\left(l\right)}{a}^{(l-1)}+b^{\left(l\right)}\right)$$

(3)

Here, $\widehat{y}$ is the predicted class probability vector (with 19 classes).

Training proceeded for 50 epochs under the Adam optimizer (initial learning rate 0.001), cross-entropy loss, and a mini-batch size of 64. The structure is presented in Figure 3a.

Although the FCN exhibited rapid convergence and delivered high overall accuracy on the test set, it proved to be insufficient for capturing the temporal structure inherent in the sliding-window RMS and phase-angle sequences. In particular, the model struggled more with classes that had only slight differences in their waveforms, like distinguishing OG from OS faults, highlighting the need for architectures that better capture the sequence and timing of signal changes. Finally, although the FCN had a relatively low inference delay, it did not perform well at capturing time-based features, which led us to explore models with convolutional and recurrent layers instead.

3.2. Proposed Convolutional Neural Network (CNN)

The second classifier leveraged a convolutional neural network (CNN) to exploit spatial correlations in the extracted features. First, the 12-dimensional feature vector at each time step was reformatted into a 3 × 4 image, keeping the correlations between features, and then fed into an image input layer. This was followed by three convolutional blocks, each consisting of the following:

• A $2\times 2$ kernel (with filter counts of 32, 64, and 128) to learn localized patterns in the current and voltage data.
• Batch normalization and ReLU activation to stabilize and accelerate convergence.
• An average-pooling layer to downsample feature maps.

Spatial features are extracted using convolutional operation:

$$f^{\left(k\right)}=\sigma \left(\sum _{c=1}^C{X}^{\left(c\right)}\ast K^{(k,c)}+b^{\left(k\right)}\right)$$

(4)

where $X^{\left(c\right)}$ is the input feature map of the cth channel, $K^{(k,c)}$ is convolutional kernel for the output channel k and input channel c, ∗ denotes the convolution operation, and $\sigma$ is the ReLU activation function.

This is followed by average pooling to downsample the feature map:

$$p_{i,j}={\displaystyle \frac{1}{mn}}\sum _{u=0}^{m-1}\sum _{v=0}^{n-1}{f}_{i+u,j+v}$$

(5)

where $m\times n$ is the pooling window size, and $p_{i,j}$ is the pooled output.

After the third pooling stage, a dropout layer ($p=0.3$) was applied to reduce overfitting, and the resulting feature maps were flattened and passed through a fully connected layer before the final softmax classifier that produced probabilities over the 19 fault and healthy classes was applied. An Adam optimizer (initial learning rate 0.001), cross-entropy loss, and a mini-batch size of 64 were used for training, which ran for 50 epochs. Figure 3b presents the visualized structure of the CNN model.

In comparative tests, the CNN significantly outperformed the FCN in overall accuracy by more effectively capturing localized distortions introduced by switch faults. However, because its receptive field remains relatively small and pooling stages break temporal continuity, the CNN struggled to model the long-term dependencies inherent in sliding-window sequences. As a result, its recall on fault classes distinguished by gradual waveform drifts (such as differentiating OG from true OS faults) was noticeably lower, highlighting the need for architectures with explicit sequence-modeling capabilities.

3.3. Proposed BiLSTM Network

Long short-term memory (LSTM) networks are a specialized form of recurrent neural networks (RNNs) that can capture long-term dependencies in sequential data due to their gated memory cells. Each LSTM cell contains three core gates (Figure 4) [39,40]:

• Input gate ($i_t$), which controls how much of the new input $x_t$ is written into the cell state.
• Forget gate ($f_t$), which determines how much of the previous cell state $c_{t-1}$ is retained.
• Output gate ($o_t$), which regulates how much of the updated cell state $c_t$ is exposed as the hidden state $h_t$.

The input to the BiLSTM consists of 12 scalar features per time step. To capture temporal dependencies, a sequence length of 50 time steps was used different from the FCN and CNN. The sequence window was implemented as a rolling buffer updated at every feature step.

At time step t, an LSTM cell receives the input vector $x_t$, the prior hidden state $h_{t-1}$, and the prior cell state $c_{t-1}$, and it computes the following:

$$\begin{array}{cc}{f}_t\hfill & =\sigma \left(W_f{x}_t+U_f{h}_{t-1}+b_f\right),\hfill \end{array}$$

(6)

$$\begin{array}{cc}{i}_t\hfill & =\sigma \left(W_i{x}_t+U_i{h}_{t-1}+b_i\right),\hfill \end{array}$$

(7)

$$\begin{array}{cc}{a}_t\hfill & =tanh\left(W_a{x}_t+U_a{h}_{t-1}+b_a\right),\hfill \end{array}$$

(8)

$$\begin{array}{cc}{c}_t\hfill & =f_t\odot c_{t-1}+i_t\odot a_t,\hfill \end{array}$$

(9)

$$\begin{array}{cc}{o}_t\hfill & =\sigma \left(W_o{x}_t+U_o{h}_{t-1}+b_o\right),\hfill \end{array}$$

(10)

$$\begin{array}{cc}{h}_t\hfill & =o_t\odot tanh\left(c_t\right),\hfill \end{array}$$

(11)

where $\sigma$ is the sigmoid function, ⊙ denotes element-wise multiplication, and W, U, and b are trainable parameters.

Although a standard LSTM processes data in one temporal direction (forward), a bidirectional LSTM (BiLSTM) enhances sequence modeling by running two LSTM layers in parallel (Figure 4). The forward LSTM

$${\overrightarrow{h}}_t=\overrightarrow{\mathrm{LSTM}}\left(x_t,{\overrightarrow{h}}_{t-1}\right)$$

(12)

operates from $t=1$ to T, while the backward LSTM

$${\overleftarrow{h}}_t=\overleftarrow{\mathrm{LSTM}}\left(x_t,{\overleftarrow{h}}_{t+1}\right)$$

(13)

runs from $t=T$ down to 1. At each time step, the two hidden states are concatenated:

$$y_t=\left[\begin{array}{c}{\overrightarrow{h}}_t\\ {\overleftarrow{h}}_t\end{array}\right],$$

(14)

thereby leveraging both past and future context for improved feature extraction and fault discrimination.

As illustrated in Figure 3c, the BiLSTM network architecture comprises the following:

• Sequence Input Layer: Receives the 12-dimensional feature vector at each time step.
• Bidirectional LSTM Layer: 200 hidden units, processing sequences in both forward and backward directions.
• Unidirectional LSTM Layer: 150 hidden units, reinforcing the forward temporal dependencies.
• Dropout Layers: Two dropout layers with a probability of $p=0.3$ to mitigate overfitting.
• Fully Connected Layer + ReLU: 128 neurons with Rectified Linear Unit activation for nonlinear feature abstraction.
• Output Layer: A fully connected layer with 19 neurons, followed by softmax activation and a classification layer to produce final class probabilities.

The network was trained using the Adam optimizer (initial learning rate 0.001) and cross-entropy loss over 50 epochs with a mini-batch size of 128.

The details for all the three networks are provided in

Table 3. Hyperparameters for deep learning models.

Model	# Hidden Layers	Neurons	Drop-Out	Max Epoch	Batch Size	Learning Rate	Loss Function
FCN	3 Fully Connected	[256 128 22]	0.3	50	64	0.001	Cross-entropy
CNN	3 Convolutional—1 Fully Connected	[256 128 22]	0.3	50	64	0.001	Cross-entropy
BiLSTM	1 BiLSTM—1 LSTM—1 Fully Connected	[200 150 22]	0.3	50	128	0.001	Cross-entropy

, and they were trained on an Apple m1 chip with 16 GB of RAM. The training time for FCN, CNN, and BiLSTM was 3.5, 87, and 27 min, respectively.

As mentioned above, all three methods take RMS values as the input feature, and they operate based on that. They also use angles to locate the faulty switch. Each type of fault causes a distinct signature on the RMS, which is learnt by the models based on their inherent learning algorithms. Following the explanation in Section 2, when OG fault occurs, RMS value decreases slightly in the corresponding phase current and increases slightly in the two other phases. When OS fault happens, the RMS decreases significantly on the corresponding phase, but there will be some fluctuations due to reverse power. This is also reflected to other phases inversely. In the case of the SC fault, the RMS shows a rapid rise in less than 2 ms. In simple words, each of these models learns these signatures, as summarized below:

• FCN detects faults based on RMS magnitude;
• CNN detects faults based on the changes in the 2D RMS-angle map;
• BiLSTM captures how RMS changes over time and uses it to detect faults.

4. Evaluation Results

The trained classifiers were validated within a MATLAB/Simulink environment by embedding each network into the V/F controlled induction-motor drive model, which includes the three-phase, two-level inverter under study. The used motor drive details are included in

Table 4. Parameters of the inverter-fed induction motor drive.

Parameter	Value
Motor Type	Squirrel cage induction motor
Motor Rated Power	5 HP
Rated Line Voltage	460 V (line-to-line)
Rated Frequency	60 Hz
Number of Poles	4
Stator Resistance ($R_s$)	1.115 $\mathrm{\Omega }$
Rotor Resistance ($R_r$)	1.083 $\mathrm{\Omega }$
Stator Inductance ($L_s$)	5.9 mH
Rotor Inductance ($L_r$)	5.9 mH
Moment of Inertia (J)	0.02 kg·m2
Friction Coefficient (B)	0.005 N·m·s
DC Bus Voltage	460 V
PWM Switching Frequency	10 kHz
Load Torque	Constant nominal torque (5 N·m)

.

Real-time measurements of accuracy, precision, recall, F1 score, and detection latency were collected for each fault scenario. Specifically, the BiLSTM network, with the best performance, was deployed as a Simulink classifier block that accepts three-phase RMS currents, voltages, and phase angles as inputs and outputs one of the fault labels defined in Table 2. The model’s online performance was evaluated across a range of motor speeds to verify consistent detection speed and classification accuracy under all simulated faults.

To summarize the test procedure, first, the trained network is integrated into a Simulink classifier block, which receives the input features and outputs the predicted fault class. To prepare the input features, the voltages and currents are buffered, and the RMS values for three phases are calculated based on the frequency from a sliding window equal to the electrical period at each time step, after which they are directly fed to the classifier. Also, the angles are directly extracted from the signals and are fed to the classifier as well. The classifier receives these 12 input features and, based on the trained weights, calculates the probabilities, and they are mapped to the fault type, which reveals the inverter faults.

The MATLAB/SIMULINK model was run under 1400 and 1800 RPM speeds, as well as during transient speed conditions, to confirm its robustness against speed. The OC, SC, and OG faults were introduced during the operation to assess the proposed FDD method. For all fault scenarios, the specific fault was applied at t = 3 s.

• Open Gate (OG): First, the OG fault detection was evaluated by constantly setting the S1 gate command to 0, making it open at t = 3 s. Figure 5a shows the fault detection at a speed of 1800 rpm. As can be seen, the detected fault label changes from 0 (healthy state) to 1 (corresponding to OG fault at S1) at t = 3.008 s, indicating an 8 ms fault detection time, which is 48% of a fundamental cycle (16.6 ms). The proposed fault detection method was tested on different speed levels (1400 rpm), and the S1 OG fault was detected in 3.6 ms, which is almost 16% of one fundamental cycle at this speed (Figure 5d). The model was also run under the speed-varying conditions indicated in Figure 5g, and again, the OG fault detection was detected in 7 ms equal to 41% of a fundamental cycle. By testing the OG fault for all six switches under different speed levels and conditions, the highest fault detection latency was less than half the fundamental cycle, showing an outstanding time for the proposed model in the case of OG faults.

  Figure 5. Fault detection using proposed BiLSTM FDD. When at t = 3, the S1 switch experiences the following faults: (a) OG at 1800 rpm, (b) OS at 1800 rpm, (c) SC at 1800 rpm, (d) OG at 1400 rpm, (e) OS at 1400 rpm, (f) SC at 1400 rpm, (g) OG during speed variation, (h) OS during speed variations, and (i) SC during speed variation.

  Figure 5. Fault detection using proposed BiLSTM FDD. When at t = 3, the S1 switch experiences the following faults: (a) OG at 1800 rpm, (b) OS at 1800 rpm, (c) SC at 1800 rpm, (d) OG at 1400 rpm, (e) OS at 1400 rpm, (f) SC at 1400 rpm, (g) OG during speed variation, (h) OS during speed variations, and (i) SC during speed variation.
• Open Switch (OS): The FDD was evaluated under OS faults for S1 under the same conditions as the OG faults. The S1 OS fault was detected (class label of 13 for S1 OS fault) under 1800rpm, 1400rpm, and varying speeds in 2.4 ms, 2.6 ms, and 3.2 ms, which is equal to 14%, 17%, and 18% of the fundamental cycle, respectively, as presented in Figure 5b,e,h. The worst-case OS fault detection time using the proposed BLSTM FDD did not exceed 20% of the fundamental cycle.
• Short Circuit (SC): The same simulations and tests were run under SC faults. Under 1800, 1400, and varying speed levels, it took the FDD method 8 ms, 6.9 ms, and 5.1 ms (48%, 32%, and 32% of the fundamental period) to detect the SC faults, and the corresponding fault label of 7 for SC faults in S1 based on Table 2 is shown. In the longest time period, it took the FDD to reveal the fault and locate the faulty switch in less than half a fundamental cycle, as illustrated in Figure 5c,f,i. It is important to note that although short-circuit protection systems in practice may disconnect the DC bus within T/6, the proposed fault detection model learns from pre-fault and early-fault waveform signatures before the DC bus is disconnected, and testing shows the successful detection of SC faults in under 48% of a fundamental cycle. This ensures compatibility with fast protection systems while enabling accurate diagnosis and localization.
• Evaluation Under Noise Existence: To evaluate the robustness of the proposed fault detection method under realistic operating conditions, additional tests were conducted by injecting white Gaussian noise and high-amplitude spikes into the input current signals. Band-limited white noise with a high amplitude up to 10% of the clean signal amplitude was added to simulate sensor-level measurement noise. In addition, a high-amplitude spikes, equal to the full signal amplitude (±5 A), was randomly introduced, resembling rare but severe disturbances like electromagnetic interference or inverter switching glitches. These spikes appeared randomly with a low probability (0.1%). Figure 6 demonstrates the noisy current.
  OG, OS, and SC faults were simulated under this noisy condition. For all of them, the motor speed was set to 1800 rpm, and the faults were injected at t = 3 s. OG, OS, and SC faults were detected in 7.3 ms, 3.4 ms, and 8.1 ms (44%, 20%, and 49% of the fundamental period), respectively, as shown in Figure 7.

  Figure 6. Clean and noisy three-phase currents.

  Figure 6. Clean and noisy three-phase currents.

Even with this added disturbance, the model continued to perform strongly, showing little to no drop in accuracy. This suggests the approach is quite robust to noise, and the model still managed to correctly detect faults, showing its ability to cope with both steady background noise and abrupt disruptions.

Showing the confusion matrices in Figure 8a–c (for FCN, CNN, and BiLSTM models, respectively), the BiLSTM model achieved a test accuracy of 98.45%, outperforming the CNN and FCN, which attained accuracies of 97.1% and 93.52%, respectively. This superior performance can be attributed to the BiLSTM’s ability to capture temporal dependencies.

Figure 7. Fault detection using proposed BiLSTM FDD in the presence of white and spike noise. When at t = 3, the S1 switch experiences faults of the following: (a) OG, (b) OS, and (c) SC at 1800 rpm.

Figure 7. Fault detection using proposed BiLSTM FDD in the presence of white and spike noise. When at t = 3, the S1 switch experiences faults of the following: (a) OG, (b) OS, and (c) SC at 1800 rpm.

To provide a comprehensive quantitative assessment of each classifier’s diagnostic capability, the following four metrics were evaluated:

• Overall Accuracy: The ratio of correctly classified instances (both fault and healthy) to the total number of samples:

  $$\mathrm{Accuracy}={\displaystyle \frac{TP+TN}{TP+TN+FP+FN}}$$
• Precision (Positive Predictive Value): Indicates the proportion of predicted faults that were genuine, i.e., the likelihood that an alarm corresponds to an actual fault:

  $$\mathrm{Precision}={\displaystyle \frac{TP}{TP+FP}}$$

  where $TP$ is the count of true positives and $FP$ the count of false positives.
• Recall (Sensitivity): Measures the ability to detect real fault instances, i.e., the fraction of actual faults correctly identified:

  $$\mathrm{Recall}={\displaystyle \frac{TP}{TP+FN}}$$

  where $FN$ denotes the number of false negatives.
• F₁-Score: The harmonic mean of precision and recall, providing a single scalar that balances the false-alarm rate against missed detections:

  $$F_1=2\times {\displaystyle \frac{\mathrm{Precision}\times \mathrm{Recall}}{\mathrm{Precision}+\mathrm{Recall}}}$$

By calculating these metrics, as provided in

Table 5. Comparison of accuracy, precision, recall, and F1 score for the FCN, CNN, and BiLSTM classifiers on the test dataset.

Model	Accuracy (%)	Precision	Recall	F1 Score
FCN	93.52	0.895	0.925	0.905
CNN	97.1	0.969	0.967	0.968
BiLSTM	98.45	0.982	0.98	0.978

, the BiLSTM achieved higher values in all factors, confirming its better performance.

Figure 8. Normalized confusion matrix for the following: (a) FCN model, (b) CNN model, and (c) BiLSTM model (blue shows the correct and orange shows wrong classification).

Figure 8. Normalized confusion matrix for the following: (a) FCN model, (b) CNN model, and (c) BiLSTM model (blue shows the correct and orange shows wrong classification).

5. Comprehensive Discussion

The results show that the proposed BiLSTM-based fault detection system performs reliably and quickly under various operating conditions in a V/F-controlled induction motor drive. Among all tested models, BiLSTM consistently delivered the best results thanks to its ability to learn and capture the time-based patterns in the input signals, including RMS values, voltage levels, and phase angles.

Conventional model-based techniques such as the ones in [11,12,14], even though they are efficient for OC fault detection, highly rely on accurate system models and are prone to parameter mismatches. The same limitation on the type of fault applies to most signal-based methods (such as [18,19]) as well, and they suffer from threshold tunings. Furthermore, based on this limitation, the generalization capability is much lower. The data-driven techniques, including [23,26,28,33], are all limited to OC fault detection, which applies to other model and signal-based methods. Ref. [5] can detect two types of OC but not the SC faults. The authors of [37] could detect the existence of OC and SC faults but could not locate the faulty switch. While [38] could detect and locate OC and SC faults, but their method is offline and has a long latency for fault detection.

Table 6. Comparison of fault diagnosis methods (✓ indicates successful fault localization, while ✗ indicates that the method is unable to locate the fault).

Ref.	Method	Fault Type	Fault Loc.	Detection Time	Notes
[10]	Current observer	OC	✓	Low	Model and adaptive threshold dependency
[14]	Current observer	OC	✓	Low	IGBT open fault only, model and adaptive threshold dependency
[16]	MPC	OC	✓	Low	IGBT open fault only, fast detection/slow localization
[18]	Clarke transform	OC	✓	Low	IGBT open fault only, threshold tuning
[5]	Ensemble bagged tree	OC	✓	Low	No SC detection
[37]	LSTM	SC, OC	✗	Low	Cannot reveal faulty switch
[38]	Applying voltage vector	SC, OC	✓	High	Offline fault detection and very slow
Proposed method	BiLSTM	SC, OC	✓	Low	Open IGBT, Open IGBT and diode, and SC fault detection; fast and robust to noise and speed levels

provides a comparison between the proposed method and some other FDD methods in the literature.

Table 6 shows that none of the prior works studied in the literature have all the features the proposed method has. The proposed method offers comprehensive detection of OG, OS, and SC faults in inverter-fed motor drives. By leveraging a noise-robust RMS-based feature set and high-overlap temporal windows, it achieves early detection (typically within half a cycle), high classification accuracy, robustness to noise and fault localization capabilities.

Figure 5 indicates that the proposed system was able to detect different types of inverter faults, such as OG, OS, and SC, within a very short time after the fault occurred. Detection occurred in less than half a fundamental cycle, and in some scenarios, such as OS faults, the model responded in just 15–20% of one cycle. This kind of fast detection is crucial for practical applications as it helps prevent further damage and ensures stable operation. Fast fault detection and localization enable system-level awareness for operators and controllers that can lead to timely support for post-fault recovery, maintenance, or smart and fault-tolerant control decisions.

Motor operating conditions, particularly speed level and its variations, play an important role in evaluating the robustness of fault detection methods. In this study, the proposed BiLSTM-based FDD system was evaluated under constant speed operations, as well as during speed transients. Across all tested scenarios, the network demonstrated consistent classification accuracy and reliable fault detection, indicating that RMS- and angle-based features preserve the characteristic signatures of OG, OS, and SC faults. This robustness arises from the fact that single-switch inverter faults introduce distinct amplitude and phase distortions that persist despite changes in motor speed.

In addition to speed variation, the influence of light-load was also investigated. The proposed method successfully detected and localized inverter faults across all tested load conditions. At very light-load operation (approximately 1 N·m and less), the fault detection latency increased and, in some cases, approached more than one fundamental cycle. This behavior is expected, as lighter loads result in lower phase-current magnitudes and reduced RMS, thereby weakening the fault signature and requiring a slightly longer observation window for confident classification. Under higher load conditions, the fault-induced distortions become more pronounced, and the detection latency remains sub-cycle.

The proposed method uses RMS-derived features, which naturally smooth out very high-frequency transients. This choice is based on practical needs and theoretical robustness. In real inverter-fed motor drives, current and voltage signals are affected by sensor noise, electromagnetic interference, and other factors. RMS processing provides a noise-resistant version of these signals, making the system less sensitive to such disturbances. As a result, the diagnostic inputs for deep learning-based fault detection become more stable and reliable. Even though RMS computation reduces very fast transient components, the results show that early signs of OG, OS, and SC faults are still clearly visible in the RMS data. This is because these faults strongly affect the current magnitude, which in turn has a major influence on the RMS values, even immediately after the fault occurs. RMS values are calculated using a sliding window that matches one fundamental cycle, and this window updates every 0.1 ms. Because of this high update rate, changes in current and voltage caused by faults start to affect the RMS values as soon as the fault happens, even before the window is filled with post-fault data. Therefore, fast detection can be carried out in less than the RMS window time. As an example, Figure 9 shows how the three-phase currents RMS values are changed when OG, OS, and SC faults occur in switch S1.

The BiLSTM architecture can track how these RMS patterns change over time, allowing for fast and reliable fault diagnosis in less than half an electrical cycle. To better show the effectiveness of the RMS feature, an ablation study was carried out as follows:

• Ablation Study on Feature Representation: To justify the selected feature representation, an ablation study was conducted by comparing the proposed RMS- and phase angle-based features with the instantaneous voltage and current features and their corresponding phase angles. In the instantaneous feature configuration, the RMS values were substituted by instantaneous values. For a fair comparison, the same BiLSTM architecture, sequence length, training parameters, and training/testing split were used across all cases.
  The results in

  Table 7. Ablation study on feature representation.

  Feature Set	Accuracy	Fault Localization Stability	Remarks
  RMS + Phase Angles (Proposed)	98.45	Stable	Robust to noise; consistent fault localization
  Instantaneous Voltages, Currents + Angles	80.5	Fluctuating	Correctly detects abnormal conditions but exhibits class oscillations during post-fault conditions

  show that while instantaneous features enable the reliable detection of the healthy operation, their overall classification accuracy is only 80.5%. Subsequent analyses show that the network accurately detects the presence of a faulty condition, but it shows varying predictions across several fault classes after the fault’s occurrence. This behavior indicates that instantaneous features provide insufficient discrimination among fault types. Also, instantaneous signals are sensitive to noise and transient disturbances, resulting in unstable fault localization.
  In contrast, RMS- and phase angle-based features yield more stable and consistent fault classification. These observations confirm that the proposed feature selection strategy offers a balance between robustness, accuracy, and real-time feasibility for inverter fault detection. Nonetheless, the instantaneous transient components may contain additional diagnostic information, and time–frequency decompositions or other advanced processing techniques might further enhance sensitivity to short-duration events.

The confusion matrix in Figure 8 supports the reliability of the BiLSTM model in classifying fault types with high confidence. The predicted labels match the actual fault classes almost perfectly, and the test accuracy of 98.45% outperforms both the CNN and FCN models. This improvement is largely due to the BiLSTM’s strength in handling time-dependent data.

The proposed BiLSTM-based FDD achieved high overall accuracy, but a few misclassifications remained in the confusion matrix. Most errors occurred between fault classes with similar electrical signatures, such as OG and OS faults on the same phase, especially immediately after the fault started. At this early stage, fault signatures are not fully developed, which can cause temporary confusion between similar fault types. When the system runs at lower current, such as during light-load operation, fault-induced distortions are less noticeable. This makes some fault patterns look more similar. Even with these challenges, the BiLSTM model could correctly identify the fault once it had enough data over time. This shows how important sequence-based learning is for telling apart similar faults. These results suggest that the remaining misclassifications are not random. Instead, they come from natural similarities in fault signatures over short periods.

The metrics in Table 5 provide a deeper look into the model’s diagnostic performance. The BiLSTM achieved the highest precision, recall, and F1 score among the tested models. A high precision score means that the system generates very few false alarms (an important feature in avoiding unnecessary system shutdowns). Similarly, a high recall shows that the system reliably detects actual faults, with very few missed cases. Together, the balanced F1 score indicates that the model not only avoids false positives but also effectively captures real faults, making it robust across all test conditions.

To evaluate statistical robustness, the proposed BiLSTM-based classifier was trained and tested over three independent runs while keeping the dataset and hyperparameters unchanged. The performance metrics are reported as mean ± standard deviation across runs. As summarized in

Table 8. Statistical robustness analysis over three independent runs.

Metric	Mean ± Std (%)
Accuracy	98.28 ± 0.32
Precision (Macro)	98.09 ± 0.33
Recall (Macro)	97.87 ± 0.39
F1 Score (Macro)	97.95 ± 0.40

, the proposed method achieved an average classification accuracy of 98.28% ± 0.32%, with a corresponding precision, recall, and F1 score of 98.09% ± 0.33%, 97.87% ± 0.39%, and 97.95% ± 0.40%, respectively. The low variance across runs indicates stable performance.

The detection times reported here are the algorithm’s decision latency, as measured in the simulation environment. These times do not include the deep learning model’s computational inference time. The proposed BiLSTM network has about 693k learnable parameters, which gives it a moderate memory footprint that works well for embedded systems. With 32-bit floating-point numbers, the model needs about 2.6–2.8 MB of memory. If implemented with 16-bit fixed-point numbers, this can be reduced to about 1.3–1.4 MB.

To provide a quantitative reference, the model’s inference time was evaluated in MATLAB by averaging the execution over 100 runs. The average inference time was 1.8 ms per prediction. This computation time is shorter than the measured fault detection time in the simulation. Feature preprocessing, including RMS and phase angle calculations and z-score normalization, involves simple operations and is negligible compared to model inference. Given the model’s size and the measured inference time in MATLAB, the proposed BiLSTM-based fault detection approach is compatible with real-time implementation on embedded controllers commonly used in motor-drive applications, such as the Texas Instruments C2000 series and ARM Cortex-M4 micro-controllers. Optimized implementations on DSP or FPGA platforms can further reduce inference latency and memory usage.

As a limitation of this study, all results are obtained using a high-fidelity simulation model of a three-phase inverter-fed induction motor drive. Simulations allow the controlled evaluation of multiple fault scenarios and operating conditions, but experimental validation is required to fully assess real-world robustness in the presence of sensor noise, parameter uncertainties, and hardware non-idealities. Hardware-in-the-loop and experimental testing on a laboratory inverter–motor setup will be considered in future work where non-destructive data collection and testing are required under safe and protected conditions, especially for SC faults. In addition, this study only considers single-switch faults, specifically individual OG, OS, and SC conditions. These are the most common and important failure types of switches in inverter-fed motor drives. Multiple-switch faults can happen; however, they usually follow an initial failure or occur in extreme situations. This work does not cover simultaneous multi-switch failures, but the proposed BiLSTM framework can be adapted to include more fault types by retraining the network. In future works, these cases would be considered to build a more complete diagnostic system. Finally, the investigated operating conditions correspond to forward motoring operation (first quadrant), which represents the normal operating mode of induction motor drives in many industrial applications. Regenerative and multi-quadrant operating modes, in which diode conduction may occur even under healthy conditions, were outside the scope of this study and will be addressed in future research.

Despite these limitations, while BiLSTM adds some computational complexity compared to simpler models, the trade-off is justified. Its improved accuracy and low false detection rates make it a strong candidate for real-time deployment. These results highlight the reliability of the proposed method and its potential for real-time diagnostic systems where quick and accurate decision-making is essential.

6. Conclusions

This paper presented a novel, data-driven fault detection and diagnosis (FDD) method based on a BiLSTM neural network for identifying, classifying, and localizing inverter switch faults in induction motor drive applications. Unlike most previous methods that focus solely on general open-circuit faults, the proposed approach distinguishes between open-gate (OG) faults and true open-switch (OS) faults, offering a more meaningful diagnosis. It also includes short-circuit (SC) fault detection, which has often been passed to hardware protection systems in earlier works.

By training three deep learning models of FCN, CNN, and BiLSTM and evaluating them comparatively, the BiLSTM model was shown to be the most effective in capturing temporal features and accurately classifying 19 fault conditions, including all fault types and switch locations. It achieved an impressive classification accuracy of 98.45%, with detection times consistently under half a fundamental cycle. These results confirm the model’s capability for real-time fault detection.

Furthermore, the method showed robustness to noise (including white and spike) and variations in motor speed under both constant and dynamic speed conditions. Its implementation in MATLAB/Simulink reinforces its practical feasibility for embedded integration into electric vehicle (EV) motor drive systems or industrial automation platforms.

The proposed FDD approach provides a high-precision tool for enhancing the reliability, safety, and maintainability of inverter-fed motor drives. Future work will explore the following:

• Experimental validation on hardware platforms to confirm real-world deployment potential;
• Including simultaneous multi-switch faults by expanding the dataset, introducing multi-label classification, and evaluating compound fault signatures under real operating conditions;
• Transfer learning strategies to generalize across different motor and inverter configurations with minimal retraining;
• Fault-tolerant control integration to enable automatic compensation and system continuity post-fault detection.

These advancements aim to transition the method from simulations to industry-ready applications, ultimately supporting the development of smarter, more resilient electrified drive systems.