In modern power conversion systems, the three-phase inverter plays a critical role in applications ranging from industrial motor drives to renewable energy integration. Ensuring the reliability of these inverters is paramount, as failures can lead to significant downtime and safety hazards. Among various failure modes, open-circuit faults in switching devices like IGBTs are particularly insidious due to their subtle initial symptoms, which can escalate into catastrophic system failures if not detected promptly. Traditional diagnostic methods often rely on manual feature extraction and heuristic models, which struggle with complex inverter topologies and varying operating conditions. To address these limitations, we explore a data-driven approach using convolutional neural networks (CNNs) for open-circuit fault diagnosis in three-phase inverters, with a focus on how sample duration and quantity impact diagnostic efficiency and accuracy.
The proliferation of AI in industrial diagnostics has enabled automated feature learning from raw data, reducing the need for expert-driven modeling. In this study, we leverage CNNs to process three-phase PWM voltage signals, which are less sensitive to load variations compared to current signals, thus providing a stable basis for fault detection. Our methodology involves generating fault samples through simulation, preprocessing the data, designing a CNN architecture optimized for local feature extraction, and evaluating performance under different sample conditions. We compare the CNN approach with traditional BP neural networks to highlight advantages in parameter efficiency, training stability, and diagnostic precision. By systematically varying sample duration and training set size, we derive insights into optimal data requirements for effective fault diagnosis in three-phase inverters.
To simulate realistic operating conditions, we developed a detailed model of a three-phase two-level inverter using MATLAB Simulink, incorporating parameters from a 1 MW system. The model includes six IGBTs, space vector PWM modulation, and practical elements like stray inductances and Gaussian noise to mimic sensor inaccuracies. We set the sampling frequency to 20 kHz, balancing the need to capture switching dynamics at 5 kHz with computational efficiency. Open-circuit faults were emulated by forcing specific IGBTs into a permanently off state, covering all single and double switch fault scenarios, plus a no-fault condition, resulting in 22 distinct fault modes. Each fault mode was encoded as a 6-element binary vector for labeling, as summarized in Table 1.
| Fault Mode | Encoding Vector |
|---|---|
| No Fault | [0, 0, 0, 0, 0, 0] |
| 1# Open | [1, 0, 0, 0, 0, 0] |
| 2# Open | [0, 1, 0, 0, 0, 0] |
| 3# Open | [0, 0, 1, 0, 0, 0] |
| 4# Open | [0, 0, 0, 1, 0, 0] |
| 5# Open | [0, 0, 0, 0, 1, 0] |
| 6# Open | [0, 0, 0, 0, 0, 1] |
| 1# and 2# Open | [1, 1, 0, 0, 0, 0] |
| 1# and 4# Open | [1, 0, 0, 1, 0, 0] |
| 1# and 6# Open | [1, 0, 0, 0, 0, 1] |
| 3# and 2# Open | [0, 1, 1, 0, 0, 0] |
| 3# and 4# Open | [0, 0, 1, 1, 0, 0] |
| 3# and 6# Open | [0, 0, 1, 0, 0, 1] |
| 5# and 2# Open | [0, 1, 0, 0, 1, 0] |
| 5# and 4# Open | [0, 0, 0, 1, 1, 0] |
| 5# and 6# Open | [0, 0, 0, 0, 1, 1] |
| 1# and 3# Open | [1, 0, 1, 0, 0, 0] |
| 1# and 5# Open | [1, 0, 0, 0, 1, 0] |
| 3# and 5# Open | [0, 0, 1, 0, 1, 0] |
| 2# and 4# Open | [0, 1, 0, 1, 0, 0] |
| 2# and 6# Open | [0, 1, 0, 0, 0, 1] |
| 4# and 6# Open | [0, 0, 0, 1, 0, 1] |
For each fault mode, we generated 350 samples of 20 ms duration (one fundamental cycle at 50 Hz) with randomized initial phases to ensure generality. Preprocessing involved normalizing the three-phase PWM voltage data to the range [-1, 1] using the formula: $$ D_{\text{nor}} = \frac{D}{d_{\text{max}}} $$ where \( D \) is the raw sample matrix and \( d_{\text{max}} \) is the maximum absolute value in \( D \). This normalization mitigates numerical issues during training and enhances generalization. The preprocessed data was structured as a 2D matrix of size \( L \times 3 \), where \( L \) is the number of samples per phase, treated as a grayscale image for CNN input. This representation allows the CNN to exploit local patterns in the voltage signals, which are crucial for distinguishing fault modes in a three-phase inverter.
Our CNN architecture, adapted from LeNet-5, includes convolutional layers for local feature extraction, pooling layers for dimensionality reduction, and fully connected layers for classification. As shown in Table 2, the network uses ReLU activation in hidden layers to accelerate convergence and Sigmoid in the output layer to approximate binary labels. In contrast, the BP network employs fully connected layers throughout, leading to a higher parameter count. The CNN’s local connectivity and weight sharing significantly reduce trainable weights—for instance, with a 20 ms sample duration, the CNN has 40,822 weights versus 256,766 in the BP network—enabling deeper networks without overfitting.
| Layer | CNN Parameters | BP Network Parameters |
|---|---|---|
| Input | One-to-one, neurons: same as input | One-to-one, neurons: same as input |
| Hidden Layer I | Convolution + Pooling: 32 filters, kernel size 16, pool size 8, strides 1 (conv) and 5 (pool) | Fully connected: 200 neurons |
| Hidden Layer II | Convolution + Pooling: 48 filters, kernel size 4, pool size 6, strides 2 (conv) and 4 (pool) | Fully connected: 80 neurons |
| Hidden Layer III | Fully connected: 64 neurons | — |
| Hidden Layer IV | Fully connected: 32 neurons | — |
| Output | Fully connected: 6 neurons | Fully connected: 6 neurons |
Training was performed using the Adam optimizer with a mean squared error loss function. We varied sample durations from 2 ms to 20 ms and training sample counts per fault mode from 20 to 300, with a fixed test set of 40 samples per mode. The batch size was set to 40, and training stopped when the loss plateaued over five epochs. The CNN model was implemented in TensorFlow-GPU 2.4.0, and training times were reasonable—e.g., 30 seconds for 10 ms samples with 160 training samples per mode. For diagnosis, network outputs were classified using Euclidean distance minimization: $$ d_{AB} = \sqrt{(a_1 – b_1)^2 + (a_2 – b_2)^2 + \ldots + (a_N – b_N)^2} $$ where \( A \) is the output vector and \( B \) is a fault label vector, ensuring robust fault mode assignment.
We evaluated performance using final loss \( L_{\text{final}} \) and diagnostic accuracy \( D_{\text{rate}} \), computed as: $$ D_{\text{rate}} = \frac{N_c}{N_a} \times 100\% $$ where \( N_c \) is the number of correct diagnoses and \( N_a \) is the total test samples. Under identical conditions, the CNN consistently achieved lower loss and higher accuracy than the BP network, as illustrated in Figure 1 for 30 training runs with 10 ms samples and 160 training samples per mode. The CNN’s stability and efficiency stem from its ability to extract local features from three-phase inverter signals, reducing parameter bloat and mitigating local minima issues.
Varying sample duration revealed that longer samples improve diagnostic performance by providing more fault information. As shown in Table 3, the CNN attained high accuracy (99.21%) with just 4 ms samples, whereas the BP network required longer durations to match this. This demonstrates the CNN’s superiority in leveraging shorter samples for efficient diagnosis in three-phase inverters.
| Sample Duration (ms) | CNN \( L_{\text{final}} \) | BP \( L_{\text{final}} \) | CNN \( D_{\text{rate}} \) (%) | BP \( D_{\text{rate}} \) (%) |
|---|---|---|---|---|
| 2 | 0.012 | 0.045 | 97.50 | 92.30 |
| 4 | 0.008 | 0.032 | 99.21 | 95.60 |
| 6 | 0.006 | 0.025 | 99.55 | 96.80 |
| 8 | 0.005 | 0.020 | 99.77 | 97.50 |
| 10 | 0.004 | 0.018 | 99.89 | 98.10 |
| 12 | 0.003 | 0.016 | 99.94 | 98.50 |
| 14 | 0.003 | 0.015 | 99.96 | 98.80 |
| 16 | 0.002 | 0.014 | 99.98 | 99.00 |
| 18 | 0.002 | 0.013 | 99.99 | 99.20 |
| 20 | 0.002 | 0.012 | 99.99 | 99.30 |
Similarly, reducing the number of training samples per fault mode highlighted the CNN’s data efficiency. With 10 ms samples, the CNN achieved 99.82% accuracy using only 40 samples per mode, while the BP network needed more data to approach this level, as detailed in Table 4. This underscores the CNN’s ability to generalize from limited data, reducing the burden of sample collection for three-phase inverter fault diagnosis.
| Training Samples per Mode | CNN \( L_{\text{final}} \) | BP \( L_{\text{final}} \) | CNN \( D_{\text{rate}} \) (%) | BP \( D_{\text{rate}} \) (%) |
|---|---|---|---|---|
| 20 | 0.015 | 0.060 | 98.50 | 90.10 |
| 40 | 0.010 | 0.040 | 99.82 | 93.50 |
| 60 | 0.008 | 0.030 | 99.88 | 95.20 |
| 80 | 0.006 | 0.025 | 99.91 | 96.50 |
| 100 | 0.005 | 0.022 | 99.93 | 97.30 |
| 120 | 0.004 | 0.020 | 99.95 | 97.80 |
| 140 | 0.004 | 0.019 | 99.96 | 98.20 |
| 160 | 0.003 | 0.018 | 99.97 | 98.50 |
| 180 | 0.003 | 0.017 | 99.98 | 98.70 |
| 200 | 0.002 | 0.016 | 99.98 | 98.90 |
| 220 | 0.002 | 0.015 | 99.99 | 99.00 |
| 240 | 0.002 | 0.014 | 99.99 | 99.10 |
| 260 | 0.002 | 0.014 | 99.99 | 99.20 |
| 280 | 0.002 | 0.013 | 99.99 | 99.30 |
| 300 | 0.002 | 0.013 | 99.99 | 99.40 |
The CNN’s efficiency is further quantified by the reduction in trainable parameters. For a three-phase inverter system, the number of weights in the CNN can be expressed as: $$ W_{\text{CNN}} = \sum_{l=1}^{L} (K_l \cdot F_l \cdot C_{l-1} + F_l) + \sum_{m=1}^{M} (N_m \cdot N_{m-1} + N_m) $$ where \( K_l \) is the kernel size, \( F_l \) is the number of filters, \( C_{l-1} \) is the input channels, and \( N_m \) is the neurons in fully connected layers. In contrast, the BP network weights grow quadratically: $$ W_{\text{BP}} = \sum_{m=1}^{M} (N_m \cdot N_{m-1} + N_m) $$ This parameter efficiency allows the CNN to deploy deeper architectures without overfitting, crucial for handling the complex dynamics of a three-phase inverter.
In conclusion, our study demonstrates that CNNs offer a robust solution for open-circuit fault diagnosis in three-phase inverters, outperforming BP networks in parameter efficiency, training stability, and accuracy under limited sample conditions. By requiring shorter sample durations and fewer training samples, the CNN reduces data acquisition costs and computational overhead, facilitating real-time deployment. Future work will focus on hardware-in-the-loop validation and extending the method to multi-level inverters and coupled fault scenarios, further enhancing the practicality of AI-driven diagnostics for three-phase inverter systems.