The solar inverter is a pivotal balance-of-system component in photovoltaic (PV) power plants. Its core switching devices, insulated-gate bipolar transistors (IGBTs), are responsible for converting the variable DC voltage from the PV array into grid-compliant AC power. IGBTs are subjected to severe thermal and electrical stresses during normal operation, which can lead to aging degradation or catastrophic open-circuit failures. A malfunctioning IGBT not only disrupts the power conversion process but may also propagate to other components, causing significant economic losses. Therefore, accurate fault detection and precise fault localization of IGBTs inside a solar inverter are of paramount importance. In this work, I propose three deep-learning-based methods that address the two dominant failure modes of IGBTs: aging-related degradation and open-circuit faults. The approaches employ temporal convolutional networks (TCNs), attention-augmented long short-term memory (LSTM) networks, and a multi-label extension of the latter to achieve robust prediction, classification, and localization of IGBT faults. I develop a two-stage three-phase grid-connected solar inverter simulation platform to acquire rich fault data, and I validate each method with extensive experiments, including noise robustness analysis. The results demonstrate that the proposed methods outperform several conventional baselines in terms of prediction accuracy, classification robustness, and localization precision.
1. Introduction
With the global shift towards renewable energy and the urgent need to reduce carbon emissions, photovoltaic power generation has become one of the fastest-growing energy sources worldwide. The solar inverter is the most critical electronic interface between the PV array and the grid. It performs both DC-to-AC conversion and grid synchronization, and it ensures maximum power point tracking is effectively achieved. The reliability of a solar inverter largely depends on the health of its power semiconductor switches. Among them, IGBTs are widely used because they combine the high input impedance of MOSFETs with the high current capability of bipolar transistors. However, IGBTs are also the most vulnerable components in the inverter due to the severe electrical, thermal, and mechanical stresses they experience during operation. A survey of failure statistics indicates that power semiconductor modules contribute to a substantial fraction of inverter failures. Consequently, effective monitoring, diagnosis, and lifetime prediction of IGBTs are essential for maintaining the availability and safety of the entire PV system.
Traditional fault detection methods for solar inverters can be roughly divided into model-based approaches, signal-processing-based approaches, and artificial-intelligence-based approaches. Model-based methods rely on mathematical models of the inverter and typically use observers or parameter estimation to generate residuals that are compared against a threshold. Signal-processing methods analyze the output voltage or current waveforms in the frequency or time-frequency domain to extract features that indicate fault conditions. More recently, data-driven techniques based on machine learning and deep learning have attracted great interest because of their ability to learn discriminative representations directly from raw signals. Among these, neural networks have shown superior performance in fault classification and remaining useful life prediction.
Most previous studies on inverter fault diagnosis used three-phase AC-side voltages or currents as monitoring signals, requiring multiple sensors. In contrast, I propose to use the DC-side current of the solar inverter as the primary monitoring signal. This configuration reduces the number of sensors — only one current sensor is needed — while still preserving the fault-related features that are embedded in the DC-link current. The DC-side current is rich in harmonic components and exhibits distinct patterns when one or two IGBTs fail. By analyzing this signal with deep recurrent and convolutional neural networks, fault detection and localization can be achieved accurately and economically.
The contributions of this paper are threefold. First, I design a temporal convolutional network to predict the aging trend of an IGBT by using the collector-to-emitter turn-off peak voltage as the aging indicator. This method handles the long-term time-series data efficiently and achieves better prediction accuracy than the LSTM and GRU baselines. Second, I construct an attention-based LSTM model for single-label open-circuit fault diagnosis of a solar inverter. The attention mechanism focuses the model on the most informative temporal features, leading to improved classification accuracy and robustness against noisy conditions. Third, I extend the attention LSTM model to a multi-label formulation that directly predicts the positions of the faulty IGBTs. This multi-label approach leverages the inherent correlations between simultaneous IGBT failures and provides a direct and precise fault-location result, thereby reducing diagnostic delay and facilitating timely maintenance.
2. System Modeling and Fault Analysis of Solar Inverter
To generate realistic fault data, I build a two-stage three-phase grid-connected PV simulation system in MATLAB/Simulink. The system consists of a PV array, a boost converter that serves as the maximum power point tracking stage, a DC-link capacitor, a three-phase voltage-source inverter with six IGBTs, a filter inductor, and a control module based on the dq-frame voltage and current double closed-loop controller. The boost stage employs the perturb-and-observe method to track the maximum power point. The inverter stage uses a current controller with voltage feedforward to maintain the output current in phase with the grid voltage. A phase-locked loop is used to synchronize the inverter with the grid.
I simulate the open-circuit faults of the IGBTs by inserting a controllable switch in series with each IGBT and opening the switch when the corresponding fault is to be emulated. The main electrical parameters of the simulation system are summarized in Table 1.
| Parameter | Value |
|---|---|
| DC-link resistance | 0.1 Ω |
| Filter inductance | 2 mH |
| Irradiance levels | 700 W/m², 1000 W/m² |
| Total simulation time | 4.1 s |
| Sampling frequency | 10 kHz |
| Grid frequency | 50 Hz |
The DC-link voltage is measured during normal operation. The voltage waveform shows a transient increase when the irradiance level changes from 700 to 1000 W/m² at t = 0.25 s, but the voltage returns to around 700 V within 50 ms due to the closed-loop control. The total harmonic distortion of the grid current is found to be 1.94%, which is below the common 2% limit, confirming the validity of the simulation.
2.1 IGBT Aging Failure Analysis
IGBT aging is primarily attributed to solder layer fatigue and aluminum bond-wire lift-off. Because the constituent materials in an IGBT module have different coefficients of thermal expansion, cyclic thermal stress leads to progressive delamination and cracking of solder joints. Additionally, bond wires connecting the silicon chip to the external terminals may crack or detach after numerous thermal cycles. These mechanisms increase the thermal resistance and electrical resistance inside the module, causing observable changes in external electrical signals.
In the accelerated aging experiments published by the NASA Prognostics Data Repository, an IGBT is subjected to repeated thermal cycles under a square-wave gate voltage. The collector-to-emitter turn-off peak voltage is recorded throughout the experiment. Analysis has shown that this peak voltage decreases significantly as the IGBT degrades, while the gate voltage and current remain nearly constant. Thus, the collector-to-emitter turn-off peak voltage serves as an effective aging indicator. In this work, I use 418 samples of this voltage collected from the NASA dataset.
2.2 Open-Circuit Fault Simulation
Open-circuit faults in solar inverter IGBTs may occur without immediately triggering a system shutdown. Unlike short-circuit faults, which are normally handled by hardware overcurrent protection, open-circuit faults often remain undetected for a longer period while the inverter continues to operate in an unbalanced condition. To avoid secondary failures, rapid and accurate detection of these faults is essential.
In the simulation system, the six IGBTs are labeled as IGBT1 through IGBT6. I consider four categories of open-circuit conditions: normal operation, single IGBT open-circuit failure, two IGBTs open-circuit in the same phase leg, two open-circuit IGBTs in the same half bridge, and two open-circuit IGBTs in different phases and different half bridges. The total number of possible fault states is 22, including the normal state. For each state, the DC-side current is sampled at 10 kHz for 4 seconds, resulting in 40,000 data points per state. Each dataset is then divided into segments of 2,000 points. The total combined dataset contains 440 segments, which are split into training and test sets in an 80/20 ratio.
Table 2 lists the single-label encoding for all 22 states. For the multi-label representation, each IGBT position is considered as a binary label, producing a 6-dimensional vector where “1” indicates the faulted IGBT. The multi-label encoding for each state is also included in Table 2.
| Fault state | Faulted switches | Single-label | Multi-label |
|---|---|---|---|
| 0 | None | 0 | [0,0,0,0,0,0] |
| 1 | IGBT1 | 1 | [1,0,0,0,0,0] |
| 2 | IGBT2 | 2 | [0,1,0,0,0,0] |
| 3 | IGBT3 | 3 | [0,0,1,0,0,0] |
| 4 | IGBT4 | 4 | [0,0,0,1,0,0] |
| 5 | IGBT5 | 5 | [0,0,0,0,1,0] |
| 6 | IGBT6 | 6 | [0,0,0,0,0,1] |
| 7 | IGBT1, IGBT4 | 7 | [1,0,0,1,0,0] |
| 8 | IGBT3, IGBT6 | 8 | [0,0,1,0,0,1] |
| 9 | IGBT2, IGBT5 | 9 | [0,1,0,0,1,0] |
| 10 | IGBT1, IGBT3 | 10 | [1,0,1,0,0,0] |
| 11 | IGBT1, IGBT5 | 11 | [1,0,0,0,1,0] |
| 12 | IGBT3, IGBT5 | 12 | [0,0,1,0,1,0] |
| 13 | IGBT4, IGBT6 | 13 | [0,0,0,1,0,1] |
| 14 | IGBT2, IGBT4 | 14 | [0,1,0,1,0,0] |
| 15 | IGBT2, IGBT6 | 15 | [0,1,0,0,0,1] |
| 16 | IGBT1, IGBT6 | 16 | [1,0,0,0,0,1] |
| 17 | IGBT1, IGBT2 | 17 | [1,1,0,0,0,0] |
| 18 | IGBT3, IGBT4 | 18 | [0,0,1,1,0,0] |
| 19 | IGBT4, IGBT5 | 19 | [0,0,0,1,1,0] |
| 20 | IGBT2, IGBT3 | 20 | [0,1,1,0,0,0] |
| 21 | IGBT5, IGBT6 | 21 | [0,0,0,0,1,1] |
3. Aging Fault Prediction Using Temporal Convolutional Network
Predicting the aging trend of IGBTs in a solar inverter enables proactive maintenance and reduces the risk of unexpected failures. In this section, I propose a method based on the temporal convolutional network (TCN) to forecast the collector-to-emitter turn-off peak voltage, which serves as the aging feature.
3.1 Data Processing
The raw aging data contains fluctuations and a few outliers. To improve the stability of the time series, I first remove the first several outliers and then apply double exponential smoothing, which is suitable for series that exhibit a trend. The smoothed series is shown in Figure 1 of the original dataset but is here described without reference to an image. After smoothing, a Min-Max normalization is applied to scale the data to a specified range. The formulas are:
$$
x_{\mathrm{std}} = \frac{x – x_{\min}}{x_{\max} – x_{\min}}
$$
$$
x_{\mathrm{scaled}} = x_{\mathrm{std}} \times (\mathrm{max} – \mathrm{min}) + \mathrm{min}
$$
Here, \(x\) is the sample value, \(x_{\max}\) and \(x_{\min}\) are the maximum and minimum values in the dataset, and \(\mathrm{max} \) and \(\mathrm{min}\) define the target interval.
3.2 Temporal Convolutional Network Architecture
TCN combines dilated causal convolutions with residual connections. The dilated causal convolution allows the network to have an exponentially growing receptive field without a proportional increase in depth. The output at position \(s\) is computed by:
$$
F(s) = \sum_{i=0}^{k-1} f(i) \cdot x_{s – d \cdot i}
$$
where \(d\) is the dilation factor, \(k\) is the kernel size, and \(f\) is the filter. In my TCN model, the dilation factors are set to \([1, 2, 4]\), the kernel size is 2, and there are 600 filters in the single convolutional layer. The model uses ReLU activation and dropout with a rate of 0.05. To avoid network degradation caused by an increasing number of layers, residual blocks are employed. Each residual block contains a 1×1 convolution branch that matches the input dimension with the output dimension if necessary. The architecture is:
Input sequence → Residual block (dilation 1) → Residual block (dilation 2) → Residual block (dilation 4) → Fully-connected layer → Prediction.
3.3 Hyperparameters and Evaluation Metrics
I compare the TCN model with LSTM and GRU models. All models are trained with the Adam optimizer and the mean squared error loss. The hyperparameters of each model are listed in Table 3.
| Model | Hyperparameters |
|---|---|
| LSTM | Learning rate 0.001, 2 hidden layers (200, 50 units), 20 epochs, optimizer Adam |
| GRU | Learning rate 0.001, 2 hidden layers (100, 50 units), 20 epochs, optimizer Adam |
| TCN | Learning rate 0.001, 1 layer, 600 filters, kernel size 2, dilation [1,2,4], dropout 0.05, optimizer Adam |
Two metrics are used to assess the prediction performance: root mean squared error (RMSE) and mean absolute error (MAE). They are defined as:
$$
\mathrm{RMSE} = \sqrt{\frac{1}{M} \sum_{i=1}^{M} (y_i – \hat{y}_i)^2}
$$
$$
\mathrm{MAE} = \frac{1}{M} \sum_{i=1}^{M} |y_i – \hat{y}_i|
$$
where \(M\) is the number of samples, \(y_i\) is the true value, and \(\hat{y}_i\) is the predicted value.
3.4 Results and Discussion
After pre-processing, the first 70% of the aging dataset is used for training and the remaining 30% for testing. Table 4 reports the RMSE and MAE values for the three models. The TCN model achieves the lowest errors: RMSE = 0.0258 and MAE = 0.0216. Compared to the LSTM model, the TCN improves both metrics by approximately 26%.
| Metric | LSTM | GRU | TCN | Improvement (TCN vs LSTM) |
|---|---|---|---|---|
| RMSE | 0.0347 | 0.0297 | 0.0258 | 25.6% |
| MAE | 0.0292 | 0.0264 | 0.0216 | 26.0% |
The superior performance of TCN can be attributed to its parallel computation ability, flexible receptive field, and residual mechanism, which avoids vanishing or exploding gradients that often affect recurrent neural networks. Moreover, the use of double exponential smoothing reduces data fluctuation and improves the learning of the underlying degradation trend, as confirmed by comparing the loss curves of models trained with and without smoothing. The smoothed data produces a more stable loss curve and lower final loss.
4. Single-Label Open-Circuit Fault Diagnosis with Attention-LSTM
Open-circuit fault diagnosis of a solar inverter is formulated as a single-label multi-class classification problem with 22 classes. In this section, I introduce an attention-augmented LSTM network to classify the fault type from the DC-side current signal.
4.1 LSTM Network
LSTM is a variant of recurrent neural networks that can capture long-term dependencies through gated cell structures. Given an input sequence \(X_t\) and the previous hidden state \(Y_{t-1}\), the LSTM cell computes the following updates:
$$
i_t = \sigma(W_i \cdot [Y_{t-1}, X_t] + b_i)
$$
$$
\tilde{C}_t = \tanh(W_c \cdot [Y_{t-1}, X_t] + b_c)
$$
$$
f_t = \sigma(W_f \cdot [Y_{t-1}, X_t] + b_f)
$$
$$
C_t = f_t \cdot C_{t-1} + i_t \cdot \tilde{C}_t
$$
$$
o_t = \sigma(W_o \cdot [Y_{t-1}, X_t] + b_o)
$$
$$
Y_t = o_t \cdot \tanh(C_t)
$$
Here, \(i_t\), \(f_t\), and \(o_t\) are the input, forget, and output gates, respectively. The cell state \(C_t\) stores long-term information. This formulation allows the network to learn relevant contextual information from the temporal input.
4.2 Attention Mechanism
While LSTM can model temporal dependencies, it treats all time steps equally when computing the final hidden state. To focus on the most discriminative time intervals, an attention layer is added. The attention mechanism computes a weight for each intermediate hidden state \(C_i\) based on its similarity to the last hidden state \(Y_t\). The scoring function used here is the dot product:
$$
\mathrm{score}_i = \gamma(Y_t, C_i)
$$
Then a softmax function normalizes the scores to obtain the attention weights:
$$
A_i = \frac{\exp(\mathrm{score}_i)}{\sum_{j=1}^{t} \exp(\mathrm{score}_j)}
$$
The context vector \(V\) is the weighted sum of the intermediate states:
$$
V = \sum_{i=1}^{t} A_i \cdot C_i
$$
Finally, \(V\) is passed through a fully connected layer to produce the classification logits. The model is trained with the cross-entropy loss:
$$
L = – \sum_{i=1}^{K} y_i \log(p_i)
$$
where \(K = 22\) is the number of classes, \(y_i\) is the one-hot ground truth, and \(p_i\) is the predicted probability.
4.3 Data Preparation and Sliding Window
The DC-side current is sampled at 10 kHz. Each fault state provides 4 seconds of data, equivalent to 40000 points, which are divided into 20 non-overlapping segments of 2000 points. To increase the number of effective samples and enhance the correlation between adjacent samples, an overlapping sliding window is used. For a segment of length 2000, a window length \(L_w\) and a stride \(S\) are chosen. The number of new samples is:
$$
N_{\mathrm{sample}} = \left\lfloor \frac{L_{\mathrm{input}} – L_{\mathrm{window}}}{S} \right\rfloor + 1
$$
I evaluated different stride values and found that a stride of 200, equal to one full cycle of the grid current (0.02 s), produces the highest classification accuracy. Thus, the final dataset consists of 22 states × 20 segments × 6 new samples = 2640 samples after windowing, with 80% used for training and 20% for testing.
4.4 Hyperparameters and Training
The Attention-LSTM model is implemented in PyTorch. The hidden size of the LSTM is set to 30 time steps for the attention window. The batch size is 16, and the learning rate is 0.001. The model is trained with the Adam optimizer for 50 epochs. Other compared methods include kNN, SVM, CNN, and LSTM. Their settings are as follows:
- kNN: number of neighbors = 7
- SVM: linear kernel
- CNN: architecture adapted to 1D input, with two convolutional layers and a fully connected layer
- LSTM: same architecture as the proposed method but without the attention layer
4.5 Results and Robustness Analysis
Table 5 presents the classification accuracies of the five methods under different signal-to-noise ratio (SNR) levels. The proposed Attention-LSTM achieves the highest accuracy at every SNR level. At 5 dB, its accuracy reaches 0.9943, while the LSTM baseline achieves 0.9867. Notably, even at -1 dB, the proposed method still maintains an accuracy above 0.95, demonstrating robust performance.
| Algorithm | -1 dB | 0 dB | 1 dB | 3 dB | 5 dB |
|---|---|---|---|---|---|
| kNN | 0.6023 | 0.6212 | 0.6452 | 0.8068 | 0.9407 |
| SVM | 0.9293 | 0.9545 | 0.9571 | 0.9697 | 0.9848 |
| CNN | 0.9283 | 0.9417 | 0.9567 | 0.9733 | 0.9783 |
| LSTM | 0.9483 | 0.9583 | 0.9633 | 0.9767 | 0.9867 |
| Attention-LSTM | 0.9545 | 0.9716 | 0.9867 | 0.9848 | 0.9943 |
A multi-class confusion matrix for the proposed method is nearly diagonal, with only a few samples of fault state 11 misclassified as fault state 16. In contrast, the LSTM model shows several more misclassifications among faults 11, 16, 12, and 18. This confirms that the attention mechanism effectively emphasizes the most salient features and suppresses irrelevant or noisy information.
Attention visualization reveals that, for normal operation, the attention weights are relatively uniform across time steps. When a fault occurs, the model concentrates most of its weight on a few specific time intervals, resulting in more distinct color differences in the heatmap. This demonstrates the ability of the attention layer to identify fault-relevant regions in the DC-side current signal.
5. Multi-Label Open-Circuit Fault Location Using Multi-Label Attention-LSTM
Although single-label classification can identify the fault category, it does not directly give the exact faulted IGBT positions unless the mapping table is consulted. To achieve direct and precise fault location, I reformulate the problem as a multi-label classification task where each of the six IGBT positions corresponds to a binary label. This approach enables the model to learn the joint dependencies among faulty IGBTs and improves the localization accuracy.
5.1 Multi-Label Classification Definition
Let \(\mathcal{X} = \mathbb{R}^d\) be the \(d\)-dimensional feature space and \(\mathcal{Y} = \{y_1, y_2, \ldots, y_q\}\) be the label space with \(q=6\). For each sample, the ground truth label vector is a binary vector indicating which IGBTs are faulty. The multi-label learning task is to train a classifier \(h\) that maps an input sample \(x\) to a label subset \(h(x) \subseteq \mathcal{Y}\). In contrast to single-label settings, labels are not mutually exclusive; one or two IGBTs can be faulty simultaneously.
5.2 Model Architecture and Loss Function
I modify the Attention-LSTM architecture by replacing the output layer. The context vector \(V\) is connected to a fully connected layer with 6 output neurons, one for each IGBT. To train this network, the binary cross-entropy loss with a sigmoid activation is used. In PyTorch, this is implemented as BCEWithLogitsLoss, which combines a sigmoid layer with the binary cross-entropy loss. The loss for a single sample is computed as:
$$
\ell_n = – \omega_n \left[ y_n \cdot \log(\sigma(x_n)) + (1-y_n) \cdot \log(1 – \sigma(x_n)) \right]
$$
$$
\mathcal{L} = \frac{1}{N} \sum_{n=1}^{N} \ell_n
$$
where \(N=6\) is the number of labels, \(\sigma\) is the sigmoid function, \(x_n\) is the output logit for label \(n\), and \(y_n\) is the ground-truth binary label. The hyperparameter \(\omega_n\) balances the sample imbalance when necessary. The final prediction is obtained by thresholding the sigmoid outputs at 0.5: a value greater than 0.5 is considered as “1”, otherwise “0”.
5.3 Experimental Results
For the multi-label experiments, the total dataset is split into training, validation, and test sets in a ratio of 3:1:1. To evaluate the robustness, additive Gaussian noise with SNR levels of -5, -3, -1, 0, 1, 3, and 5 dB is applied to the input data. The training and validation losses decrease rapidly and saturate after approximately 20–35 epochs, depending on the noise level. At higher SNR, the loss approaches zero and accuracy approaches one faster. Even at -1 dB, the multi-label model achieves a stable accuracy of 0.9919, which is higher than the single-label Attention-LSTM (0.9545 at -1 dB) because the multi-label formulation leverages the structural correlation among IGBTs.
Table 6 lists the accuracy values for the proposed multi-label Attention-LSTM (denoted as ML-Attention-LSTM) and the single-label methods at various SNR levels. The multi-label method consistently outperforms both the LSTM and Attention-LSTM baselines. At 5 dB, its accuracy reaches 0.9980. Furthermore, I test the model at -3 dB and -5 dB SNR, where it still achieves 0.9838 and 0.9661, respectively, demonstrating excellent noise immunity.
| Algorithm | -5 dB | -3 dB | -1 dB | 0 dB | 1 dB | 3 dB | 5 dB |
|---|---|---|---|---|---|---|---|
| LSTM | — | — | 0.9483 | 0.9583 | 0.9633 | 0.9767 | 0.9867 |
| Attention-LSTM | — | — | 0.9545 | 0.9716 | 0.9867 | 0.9848 | 0.9943 |
| ML-Attention-LSTM | 0.9661 | 0.9838 | 0.9919 | 0.9954 | 0.9968 | 0.9959 | 0.9980 |
The multi-label method enables direct and precise identification of the faulty IGBTs. For example, an output vector of \([1,1,0,0,0,0]\) immediately indicates that IGBT1 and IGBT2 are open-circuit. This eliminates the extra step of looking up a single-label mapping table and therefore significantly reduces the diagnostic time. The study on multi-label classification demonstrates that exploiting inter-label correlations can improve fault localization performance, especially when multiple IGBTs fail simultaneously.
6. Conclusion
In this paper, I have presented three deep-learning-based methods for fault detection and localization in a solar inverter. The first method uses a temporal convolutional network to predict the aging trend of IGBTs based on the collector-to-emitter turn-off peak voltage. Experimental results on the NASA accelerated aging dataset show that the TCN model achieves lower RMSE and MAE than LSTM and GRU, confirming its superior ability to model long-term degradation trends with parallel processing and flexible receptive fields.
The second method combines an LSTM network with an attention mechanism to classify open-circuit faults from the DC-side current of a solar inverter. The attention layer dynamically weights the importance of different time steps, enabling the model to focus on fault-relevant features. Comprehensive experiments under various SNR levels demonstrate that the proposed Attention-LSTM method improves classification accuracy and robustness compared with conventional methods such as kNN, SVM, CNN, and plain LSTM.
Finally, the third method extends the Attention-LSTM to a multi-label classification formulation for direct fault localization. By treating each IGBT position as a binary label and using a binary cross-entropy loss, the model can output the exact set of faulty IGBTs. This multi-label approach not only leverages correlations among simultaneous faults but also achieves higher localization accuracy and better noise robustness than the single-label counterparts, even under very strong noise conditions.
The three methods together provide a comprehensive framework for solar inverter health monitoring and maintenance. Future work could focus on validating the methods with hardware-in-the-loop experiments, incorporating more failure modes, and optimizing the models for real-time embedded deployment. Overall, the proposed deep-learning-based approaches demonstrate strong potential for practical solar inverter fault detection and localization applications.