Euclidean Distance-Based Tree Algorithm for Fault Detection and Diagnosis in Photovoltaic Systems

Abstract

In this paper, a new methodology for fault detection and diagnosis in photovoltaic systems is proposed. This method employs a novel Euclidean distance-based tree algorithm to classify various considered faults. Unlike the decision tree, which requires the use of the Gini index to split the data, this algorithm mainly relies on computing distances between an arbitrary point in the space and the entire dataset. Then, the minimum and the maximum distances of each class are extracted and ordered in ascending order. The proposed methodology requires four attributes: Solar irradiance, temperature, and the coordinates of the maximum power point (Impp, Vmpp). The developed procedure for fault detection and diagnosis is implemented and applied to classify a dataset comprising seven distinct classes: normal operation, string disconnection, short circuit of three modules, short circuit of ten modules, and three cases of string disconnection, with 25%, 50%, and 75% of partial shading. The obtained results demonstrate the high efficiency and effectiveness of the proposed methodology, with a classification accuracy reaching 97.33%. A comparison study between the developed fault detection and diagnosis methodology and Support Vector Machine, Decision Tree, Random Forest, and K-Nearest Neighbors algorithms is conducted. The proposed procedure shows high performance against the other algorithms in terms of accuracy, precision, recall, and F1-score.

1. Introduction

The worldwide demand for electrical energy continues to increase, and the governments of different nations must face several challenges to effectively respond to this demand. The first challenge is to provide energy for the growing proportion of the world’s population [1,2,3], while the second challenge lies in the production of this energy without causing environmental pollution or causing climatic problems such as global warming [4,5,6].

One of the ways to reduce greenhouse gas emissions is to use renewable energy, such as wind and solar energies. The wind and the sun provide infinite amounts of energy without generating greenhouse gases, unlike fossil-fuel-burning electric power stations. Solar energy allows producing electricity from photovoltaic panels or solar thermal power stations, thanks to sunlight captured by solar panels. Solar energy is clean, does not emit any greenhouse gases, and its source—the sun—is free, inexhaustible, and available everywhere in the world. Several countries around the globe are already at the forefront of renewable energy technologies and generate a large part of their electricity from photovoltaic systems (PVSs).

Like all other industrial process, a PVS can be subjected, during its operation, to various faults and anomalies, leading to a drop in the performance of the system and even to the total unavailability of the system. These faults will deviously reduce the productivity of the installation [7] and generate an additional cost of maintenance to restore the system to normal conditions—hence, the importance of having a system to detect and diagnose faults in system photovoltaic installation, which contributes to raising production efficiency and reducing maintenance time and cost [8].

There are many research contributions over the past decades in developing methods and algorithms for detecting and diagnosing faults in PV systems [9,10,11]. According to references [12,13], these algorithms can be classified into three distinct categories, whereas in reference [14], they are grouped into six categories. In this quick narration, the first categorization is adopted.

The first category encompasses all algorithms that use mathematical analysis and signal processing. Methods within this category heavily rely on the information extracted solely from the I–V characteristic, whether it pertains to a photovoltaic module (PVM), a PV string, or a photovoltaic array (PVA). Time Domain Reflectometry (TDR) is a technique utilized for identifying faulty photovoltaic modules within a photovoltaic array [15,16]. It has been employed to detect open circuits in grid-connected photovoltaic systems (GCPV) [17,18]. Earth Capacitance Measurement (ECM) has been added to the TDR to identify the PV module disconnected from the PV string [18]. Reference [18] has demonstrated the applicability of the ECM algorithm in PV strings made of both silicon and amorphous silicon.

The second category comprises several algorithms characterized by two main phases: the detection phase, utilizing a PV model, and the subsequent diagnosis phase, employing various methods, such as artificial intelligence [19,20,21,22]. These algorithms detect faults by comparing the measured values extracted from the considered PV generator with the simulated values from the PV model. The residual signal derived from this comparison can be utilized to detect degradation faults [23] as well as various cases of line-to-line faults [24].

The third category encompasses artificial intelligence and machine learning algorithms, including support vector machine (SVM) [25,26,27,28,29], decision tree (DT) [7,30], random forest (RF) [31,32,33], K-nearest neighbors (KNN) [34,35,36], and artificial neural network (ANN) [37,38,39] algorithms. Reference [25] provides a comparison of efficiency and execution time among various multiclass strategies—such as one vs. all (OVA), adaptive directed acyclic graph (ADAG), and decision-directed acyclic graph (DDAG) utilizing SVM. The goal of SVM classification is to categorize data into four classes: module short circuit, inverse bypass diode module, shunted bypass module, and shadowing effect in a module. The OVA strategy has demonstrated significant superiority over others in terms of efficiency, achieving an 88.33% accuracy rate. In reference [26], the SVM algorithm was employed to detect series faults of 10%, 50%, 70%, and 90% under sunny, cloudy, and rainy weather conditions. The recorded accuracies were 88.3%, 91.5%, and 75.3%, respectively. In reference [27], both the CPA and SVM algorithms were utilized to identify four operating states: normal, open circuit, short circuit, and partial shading. The authors concluded that with k = 6 (number of dimension), the algorithm achieved an accuracy rate of 100%. In reference [28], the authors used the SVM algorithm to detect faults such as open circuit, short circuit, and lack of solar radiation. The algorithm requires four inputs: short-circuit current Isc, open-circuit voltage Voc, and coordinates of maximum power point Impp and Vmpp. The algorithm’s efficiency and accuracy were enhanced by employing k-fold cross-validation. The drawback with the mentioned algorithms is that their authors solely relied on accuracy as the criterion for evaluation, whereas employing different metrics like precision and recall could offer a more comprehensive assessment of the algorithms.

In [7], a novel approach based on the DT algorithm is presented. This approach comprises two models: the first model detects faults, while the second model diagnoses four different fault types: short circuit, string, line-to-line, and free faults. The accuracy rates for the first and second models are 99.86% and 99.80%, respectively. Notably, although a confusion matrix was calculated, precision and recall metrics were not evaluated. The utilization of the random forest algorithm for fault detection and classification in PV systems is highlighted in [31]. The method introduced in this study necessitates the current from each string in the PV array, along with the PV array voltage, as features. Successfully, the algorithm detects and diagnoses four different faults: degradation, partial shading, line-to-line, and short-circuit faults. Authors have employed the grid-search method to optimize the random forest parameters. In order to evaluate this method, experimental and simulation samples were used. The accuracy of this method reached 99%. Another method was developed based on RF to detect and diagnose faults in photovoltaic systems [32]. A set of criteria were used to evaluate the method, which are computation time, accuracy, and F1-score. In [34], a modified KNN algorithm was proposed and applied to photovoltaic systems for fault detection and diagnosis. The main modification made by the researchers in this work is to facilitate the selection of the appropriate K value in addition to the distance function. This modification greatly contributed to the increase in the classification speed. Moreover, in [35], an interesting technique that uses the KNN algorithm was developed to detect multiple faults, including line-to-line and partial shading faults. Remarkably, this method only relies on data from the datasheet and achieves an accuracy rate of 99%. Another model was developed based on the combination of KNN and the Exponential Weighted Moving Average (EWMA) [36]. The KNN aims to detect faults on the DC side of the PV system, while the EMWA works to diagnose those faults. Researchers in [37] built a two-stage classifier: the first stage was a model of the PV system to detect faults, while the second stage was devoted for diagnosis purposes, in which two artificial neural networks were used to identify eight different faults. In [38], another approach based on artificial neural networks for fault detection and diagnosis in PV systems was introduced. The authors utilized an ANN with radial basis function (RBF) architecture, relying on two features: power generated and solar irradiance. The achieved accuracy in this study was 97.9% for the 2.2 kW PV system and 97% for the 4.16 kW PV system.

In this work, a novel fault detection and diagnosis algorithm is developed and designed in the DC of PV systems. This methodology is based on an innovative tree algorithm that mainly depends on calculating Euclidean distances to detect faults when they occur, effectively. At first, the algorithm classifies the data into two classes so that all the distances between a random point in space and the entire data set are calculated. Then, in each class, the minimum and maximum distances are extracted. After that, all the distances are arranged in ascending order to show one case out of five possible cases. Based on the apparent case, the data are classified. The algorithm needs four features to function properly: solar radiation, temperature, and current and voltage at the maximum power point. This algorithm has been implemented to seven different classes: normal operation, series disconnection, short circuit for 3 and 10 modules, and three other classes for series disconnection with partial shading of 25%, 50%, and 75%. The efficiency and effectiveness of the methodology is clearly demonstrated by the accuracy rate achieved, which exceeds 97%. In order to further evaluate the algorithm, a comparative study was conducted between the proposed algorithm and several well-known algorithms (support vector machine, K-nearest neighbors, decision tree, and random forest). The comparison results show a clear superiority of the developed algorithm in terms of accuracy, precision, recall, and F1-score.

This paper is organized as follows: Section 2 is dedicated to introducing the developed algorithm, while Section 3 explains the database used and its different categories. Section 4 reveals the classification strategy followed in this work. In Section 5, the results obtained are presented and discussed. The last section of this paper presents a summary of the work done in this research paper

2. Proposed Euclidean-Based Decision Tree Classification Algorithm

Despite the similarities between the proposed algorithm and the decision trees in their data splitting approach, the key distinction lies in using the Euclidean distance for partitioning data instead of the Gini index.

Initially, a training dataset, comprising values for $N$ features for each of the two classes (class 0 and class 1), is created. Then, the following steps are performed:

(a)

Choose an arbitrary point $(x_1, x_2,\dots ,x_N)$ in an $N$-dimensional space.

(b)

Using Equations (1) and (2), compute the Euclidean distances between the chosen point and all samples within the training dataset for each respective class:

$${dist}_i^0= \sqrt{{(x_1-x_{i1}^0)}^2+ {(x_2-x_{i2}^0)}^2+ \dots + {(x_N-x_{iN}^0)}^2} i=\mathrm{1,2},\dots ,n$$

(1)

$${dist}_i^1= \sqrt{{(x_1-x_{i1}^1)}^2+ {(x_2-x_{i2}^1)}^2+ \dots + {(x_N-x_{iN}^1)}^2} i=\mathrm{1,2},\dots ,m$$

(2)

where $(x_{i1}^0, x_{i2}^0, \dots , x_{in}^0)$ and $\left(x_{i1}^1, x_{i2}^1, \dots , x_{im}^1\right)$ represent the ith samples of class 0 and class 1, respectively. $n$ denotes the number of samples in class 0, while m denotes the number of samples in class 1. At this point, two vectors are obtained: ${dist}^0$ and ${dist}^1$. ${dist}^0$ contains distances computed between the arbitrary point and all data in the training set that belong to class 0, while ${dist}^1$ contains distances computed between the arbitrary point and all data in the training set that belong to class 1.

(c)

Determine the minimum and maximum distances for each class:

$${min}_0=\underset{\mathit{i}=\mathrm{1,2},\dots ,n}{\min }({dist}_i^0)$$

$${max}_0=\underset{\mathit{i}=\mathrm{1,2},\dots ,n}{\max }({dist}_i^0)$$

$${min}_1=\underset{\mathit{i}=\mathrm{1,2},\dots ,m}{\min }({dist}_i^1)$$

$${max}_1=\underset{\mathit{i}=\mathrm{1,2},\dots ,m}{\max }({dist}_i^1)$$

Minimum and maximum values (${min}_0, {max}_0, {min}_1, {max}_1$) as well as the arbitrary point coordinates are considered as the algorithm parameters which are needed in the testing phase.

(d)

Merge the two vectors ${dist}^0$ and ${dist}^1$ into one vector. Then, arrange the vector in ascending order. Among the following five cases, one may arise:

• case 1: ${min}_0<{min}_1<{max}_0<{max}_1$
  Figure 1 shows a graphical representation of the first case.

  -

  Training sample shaving distances within the interval $[{min}_0, {min}_1[$ belong to class 0 (pure data in class 0).

  -

  Training samples having distances within the interval $]{max}_0, {max}_1]$ belong to class 1 (pure data in class 1).

  -

  Training samples having distances within the interval $[{min}_1, {max}_0]$ cannot be classified; therefore, another random point must be chosen for their classification.

• case 2: ${min}_1<{min}_0<{max}_1<{max}_0$
  Figure 2 shows a graphical representation of the second case.

  -

  Training samples having distances within the interval $[{min}_1, {min}_0[$ belong to class 1 (pure data in class 1).

  -

  Training samples having distances within the interval $]{max}_1, {max}_0]$ belong to class 0 (pure data in class 0).

  -

  Training samples having distances within the interval $[{min}_0, {max}_1]$ cannot be classified; therefore, another random point must be chosen for their classification.

• case 3: ${min}_0<{min}_1<{max}_1<{max}_0$
  Figure 3 shows a graphical representation of the third case.

  -

  Training samples having distances within the interval $[{min}_0, {min}_1[$ or $]{max}_1, {max}_0]$ belong to class 0.

  -

  Training samples having distances within the interval $[{min}_1, {max}_1]$ cannot be classified; therefore, another random point must be chosen for their classification.

• case 4: ${min}_1<{min}_0<{max}_0<{max}_1$
  Figure 4 shows a graphical representation of the forth case.

  -

  Training samples having distances within the interval $[{min}_1, {min}_0[$ or $]{max}_0, {max}_1]$ belong to class 0.

  -

  Training samples having distances within the interval $[{min}_0, {max}_0]$ cannot be classified; therefore, another random point must be chosen for their classification.

• case 5: ${min}_0<{max}_0<{min}_1<{max}_1$ or ${min}_1<{max}_1<{min}_0<{max}_0$
  Figure 5 shows a graphical representation of the fifth case.

  -

  Training samples having distances within the interval $[{min}_0, {max}_0]$ belong to class 0.

  -

  Training samples having distances within the interval $[{min}_1, {max}_1]$ belong to class 1.

(e)

If the case that occurred in the previous step is case 1, 2, 3, or 4:

-

Choose another random point $(x_1, x_2,\dots ,x_N)$.

-

Using Equations (1) and (2), compute the Euclidean distances between the chosen points and the unclassified samples within the training dataset for each respective class.

-

Go to step (c).

(f)

The algorithm iterates through steps (c) to (e) until all data are classified (case 5) or the stopping criterion is met. It employs early stopping as its stopping criterion to effectively mitigate overfitting without compromising the accuracy of the algorithm [40,41,42]

To address the overfitting issue, the difference between test accuracy and training accuracy is calculated. This difference should be minimal (less than 3% for example). If it exceeds this threshold, the training process is halted.

Figure 6 provides a graphical illustration of the proposed algorithm depicting a given possible situation.

The flowchart of the algorithm is given in Figure 7.

Algorithm 1 presents the pseudo-code of the proposed algorithm.

Algorithm 1. Pseudo-code of the proposed algorithm

STEP (a): Generate a random point. STEP (b): Using Equations (1) and (2), calculate the distances ${dist}_i^0$ and ${dist}_j^1 , (i=\mathrm{1,2},\dots ,n j=\mathrm{1,2},\dots ,m)$. STEP (c): Find ${min}_0, {min}_1, {max}_0, {max}_1$, the minimal and maximal distances of each class. STEP (d): Store the computed di-stances int a vector named $dist$ and organize it in ascending order. STEP (e): $j=1$ (the counter for unclassified data) - If $min0<min1<max0<max1$     For $i=1$ to $k$ ($k=n+m.$)        If $min0\le dist\left(i\right)<min1$         The point associated to $dist\left(i\right)$ belongs to $class 0$       elseif $max0<dist\left(i\right)\le max1$         The point associated to $dist\left(i\right)$ belongs to $class 1$       Else ($min1\le dist\left(i\right)\le max0$)         $Unclassified(j:)=trainingset(i:)$         Increment $j$ End if     END for     $trainingset=Unclassified$. if the stopping criteria is not verified Choose a new arbitrary point. Calculate the distances ${dist}_i^0$ and ${dist}_j^1$ for unclassified data. Go to step (c). Else Go to step (f). End if Elseif $min1<min0<max1<max0$       For $i=1$ to $k$       If $dist\left(i\right)<min0$         The point associated to $dist\left(i\right)$ belongs to $class 1$       elseif $max1<dist\left(i\right)$         The point associated to $dist\left(i\right)$ belongs to $class 0$       Else  ($min0\le dist\left(i\right)\le max1$)       $Unclassified(j:)=trainingset(i:)$       Increment $j$ End if       END for $trainingset=Unclassified$. if the stopping criteria is not verified Choose a new arbitrary point. Calculate the distances ${dist}_i^0$ and ${dist}_j^1$ for unclassified data. Go to step (c). Else Go to step (f). End if. Elseif $min0<min1<max1<max0$       For $i=1$ to $k$       If $dist\left(i\right)<min1$ or $max1<dist\left(i\right)$         The point associated to $dist\left(i\right)$ belongs to $class 0$       Else      ($min1\le dist\left(i\right)\le max1$)         $Unclassified(j:)=trainingset(i:)$         Increment $j$ End if       END for $trainingset=Unclassified$. if the stopping criteria is not verified Choose a new arbitrary point. Calculate the distances ${dist}_i^0$ and ${dist}_j^1$ for unclassified data. Go to step (c). Else Go to step (f). End if. Elseif $min1<min0<max0<max1$       For $i=1$ to $k$       If $dist\left(i\right)<min0$ or $max0<dist\left(i\right)$         The point associated to $dist\left(i\right)$ belongs to $class 1$       Else ($min0\le dist\left(i\right)\le max0$)       $Unclassified(j:)=trainingset(i:)$       Increment $j$ End if       END for $trainingset=Unclassified$. if the stopping criteria is not verified Choose a new arbitrary point. Calculate the distances ${dist}_i^0$ and ${dist}_j^1$ for unclassified data. Go to step (c). Else Go to step (f). End if. Else  (($min0<max0<min1<max1$) or ($min1<max1<min0<max0$))       For$i=1$ to $k$       If $min0\le dist\left(i\right)\le max0$         The point associated to $dist\left(i\right)$ belongs to $class 0$       If $min1\le dist\left(i\right)\le max1$         The point associated to $dist\left(i\right)$ belongs to $class 1$       END for         Go to step (f) End if Step (f): End (all data are classified or the stopping criterion is met).

3. Dataset Description

The PV array used to generate the dataset, for both healthy and faulty states, consists of two parallel strings. Each string comprises fifteen series-connected Isofoton PVM (106 W–12 V), modeling a realistic photovoltaic (PV) system located at a research center in Bouzareah, Algeria. The Simulink/MATLAB 2015a platform is utilized to simulate the current (Impp) and voltage (Vmpp) at the maximum power point of this PV array under both healthy and faulty states, considering various values of cell temperature (T) and irradiance (G). Through this simulation, 753 samples are generated for each of the considered classes, consisting of the four physical quantities (T, G, Impp, Vmpp). In this study, besides the normal operating state, six faulty states are considered. These states and their corresponding labels are given in

Table 1. Operating states and their labels.

Class Name	Label
Normal operation	Class 0
Short circuit of three modules	Class 1
Short circuit of ten modules	Class 2
String disconnection	Class 3
String disconnection with 25% of partial shading	Class 4
String disconnection with 50% of partial shading	Class 5
String disconnection with 75% of partial shading	Class 6

. Environmental factors such as dust accumulation, adverse weather conditions, and snowfall often lead to partial shading faults. The algorithm’s ability to detect and classify such faults has been rigorously tested (refer to Table 1 for the examined faults). Results demonstrate a high degree of accuracy in diagnosing these issues. However, module aging, which gradually degrades PV system performance, was not included in this study. Future research will incorporate this factor to enhance fault detection capabilities further.

Before fitting the classifier, the dataset needs to be preprocessed. Three steps are included: attribute normalization, where input data are scaled to preserve the consistency in computing distances; data structuring by adding labels for each data point to create a labeled dataset; and filtering out of outlier data.

The proposed algorithm is an excellent candidate to implement it in large-scale PV farms. Its reliance on key attributes ensures rapid fault detection, making it well suited for real-time monitoring and diagnosis in large-scale installations.

As shown in Figure 8, utilizing the Impp as a feature makes it possible to distinguish between three faults: string disconnection, string disconnection with 50% shading, and string disconnection with 75% shading. Meanwhile, in Figure 9, it appears that the Vmpp feature can be used to classify faults such as string disconnection with 25% shading, short circuits of three modules, and short circuits of ten modules. To detect the healthy state class, both Impp and Vmpp features must be used simultaneously.

In fact, the proposed algorithm was tested on a dataset containing four classes. Subsequently, it was generalized to a more complex dataset with seven classes, as presented in this study.

4. Fault Detection and Diagnosis Methodology

The flowchart of the classification strategy used is shown in Figure 10. In order for the algorithm to function effectively, the multi-class dataset must be adapted to a bi-class dataset by isolating one class at a time, starting from class 0 and going up to class 6. Therefore, six classifiers must be designed for this purpose.

The first, the second, and the third classifiers isolate classes 0, 1, and 2 from the rest of the classes, respectively. Then, the fourth classifier isolates class 4 from classes 3, 5, and 6. The fifth classifier separates class 3 from classes 5 and 6. Finally, the sixth classifier distinguishes between classes 5 and 6.

Each classifier is designed based on the classification algorithm described previously and uses the four specified features (T, G, Impp, and Vmpp).

5. Results and Discussion

The confusion matrix is a well-known and important mathematical tool in the field of machine learning for evaluating algorithms. The elements of this matrix play a role in calculating the accuracy, precision, and recall metrics. This matrix has two rows and two columns, as illustrated in

Table 2. Confusion matrix used to evaluate the algorithm.

Predicted Classes
Real class	Class 0	Class 1
Class 0	TP	FN
Class 1	FP	TN

TP: stands for True Positive, which means the number of data that are in class 0 in the dataset which the algorithm successfully considered to be in class 0; FN: stands for False Negative, which means the number of data that are in class 0 in the dataset which the algorithm considered to be in class 1; FP: stands for False Positive, which means the number of data that are in class 1 in the dataset which the algorithm considered to be in class 0; TN: stands for True Negative, which means the number of data that are in class 1 in the dataset which the algorithm successfully considered to be in class 1.

.

The four three metrics are computed as follows:

• Accuracy: A metric that shows how many data the algorithm correctly classifies. It is given by

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

(3)

• Precision: Measures the proportion of correctly predicted positive data to the total data predicted as positive. It is given by

$$Precision={\displaystyle \frac{TP}{TP+FP}}\times 100$$

(4)

• Recall: A metric that shows how many data that are really in class 1 which the classifier correctly predicted to be in class 1. It is given by

$$Recall={\displaystyle \frac{TP}{TP+FN}}\times 100$$

(5)

• F1-score: Measures the harmonic mean between the precision and the recall. It is given by

$$F1-score=2\times {\displaystyle \frac{Precision\times Recall}{Precision+Recall}}$$

(6)

5.1. Training the Fault Detection and Diagnosis Model Using the Proposed Algorithm

Like any other statistical learning algorithm, the proposed algorithm firstly needs to be trained using a training dataset. Following training, its performance is evaluated using a separate testing set. The dataset is partitioned into two subsets: the training set comprises 87% of the global dataset, while the testing set encompasses 13% of the global dataset. As mentioned earlier, six classifiers are necessary to detect and diagnose the specified faults. To mitigate overfitting effectively without compromising the algorithm’s accuracy, the early stopping criterion is employed to stop the training process of each classifier.

The accuracy metric for each classifier is calculated at every iteration and illustrated in Figure 11, Figure 12, Figure 13, Figure 14, Figure 15 and Figure 16. As can be seen, for all classifiers, the accuracy value increases over iterations. Classifiers 1 to 6 of the trained model require 23, 9, 4, 6, 16, and 17 steps, respectively, to separate a class from the other classes.

5.2. Evaluating the Performance of the Obtained Model Using the Proposed Algorithm

The performance of the proposed approach is evaluated using the average values of precision, precision, and recall. The higher these values, the better the performance of the proposed approach is, and vice versa. The confusion matrices and values of the three metrics are calculated from the test dataset. The results are presented in

Table 3. Confusion matrices for the obtained model.

	TP	FN	FP	TN
Classifier 1	1107	19	29	168
Classifier 2	947	3	4	178
Classifier 3	762	1	3	183
Classifier 4	570	3	1	190
Classifier 5	354	13	10	179
Classifier 6	177	20	5	155

and

Table 4. Metric values for the obtained model.

	Accuracy (%)	Precision (%)	Recall (%)	Execution Time (s)	F1-Score (%)
Classifier 1	97	93	85	0.98	98
Classifier 2	99	98	98	0.79	100
Classifier 3	100	99	98	0.51	100
Classifier 4	99	98	99	0.31	100
Classifier 5	96	93	95	0.21	98
Classifier 6	93	89	97	0.06	93
Average values	97.33	95	95.33	0.47	98.2

, respectively.

Table 3 presents the confusion matrix values for each classifier within the resulting model. These values were used to calculate the precision, accuracy, and recall measures for all six classifiers and are presented in Table 4. The last row of Table 4 shows the average values of the three measures, which represent the measures of the resulting model.

Two additional train–test variants were conducted, and the results are presented in

Table 5. Metric values for the obtained model with a second train–test variant.

	Accuracy (%)	Precision (%)	Recall (%)	F1-Score (%)
Classifier 1	98	99	99	99
Classifier 2	99	100	100	100
Classifier 3	100	100	100	100
Classifier 4	100	100	100	100
Classifier 5	97	97	99	98
Classifier 6	96	97	96	96
Average values	98.33	99	99	99

and

Table 6. Metric values for the obtained model with a third train–test variant.

	Accuracy (%)	Precision (%)	Recall (%)	F1-Score (%)
Classifier 1	98	99	99	99
Classifier 2	100	100	100	100
Classifier 3	100	100	100	100
Classifier 4	99	100	100	100
Classifier 5	99	99	99	99
Classifier 6	99	98	99	98
Average values	99	99.33	99.5	99.33

.

Table 5 and Table 6 highlight the accuracy for the fault detection and diagnosis model across all classifiers under varied training and testing scenarios.

5.3. Comparative Studyy of Various Machine Learning Algorithms

In this comparative study, the fault detection and diagnosis model depicted in the flowchart of Figure 5 is constructed using various statistical methods, namely, the SVM algorithm [27], the DT algorithm [8,31], the RF algorithm [32,33,34], and the KNN algorithm [35,36,37].

The confusion matrices for the obtained model using the aforementioned algorithms are provided in

Table 7. Confusion matrices for the obtained model using the four algorithms.

	SVM				DT				RF				KNN
	TP	FN	FP	TN	TP	FN	FP	TN	TP	FN	FP	TN	TP	FN	FP	TN
Cl 1	1104	15	165	34	1113	6	23	176	1119	8	15	176	1107	12	155	44
Cl 2	1086	0	122	61	950	3	3	180	950	1	1	180	1078	1	1	182
Cl 3	1021	0	103	84	765	2	0	186	764	0	1	186	892	0	0	187
Cl 4	927	0	107	90	566	3	0	196	568	1	0	196	696	0	0	196
Cl 5	796	57	131	50	364	10	7	185	371	4	3	185	508	1	167	20
Cl 6	631	112	84	90	163	29	172	202	157	36	175	202	105	73	201	296

, while

Table 8. Metric values for the obtained model using the four algorithms.

		SVM	DT	RF	KNN
Classifier 1	Accuracy (%)	86	98	99	87 (K = 7)
	Precision (%)	87	98	99	88
	Recall (%)	99	99	100	99
	F1-score (%)	92	99	99	93
	Execution time (s)	0.28	0.02	0.008	0.21 (K = 1)
Classifier 2	Accuracy (%)	90	99	100	100
	Precision (%)	90	100	100	100
	Recall (%)	100	100	100	100
	F1-score (%)	93	91	100	100
	Execution time (s)	0.29	0.03	0.05	0.17
Classifier 3	Accuracy (%)	91	100	100	100 (K = 3)
	Precision (%)	91	100	100	100
	Recall (%)	100	100	100	100
	F1-score (%)	100	100	100	100
	Execution time (s)	0.05	0.004	0.07	0.15
Classifier 4	Accuracy (%)	90	100	100	100 (K = 2)
	Precision (%)	90	100	100	100
	Recall (%)	100	99	100	100
	F1-score (%)	87	98	100	100
	Execution time (s)	0.14	0.003	0.05	0.12
Classifier 5	Accuracy (%)	82	97	99	76 (K = 35)
	Precision (%)	86	98	99	75
	Recall (%)	93	97	99	100
	F1-score (%)	86	98	99	86
	Execution time (s)	0.16	0.003	0.06	0.11
Classifier 6	Accuracy (%)	78	64	63	59 (K = 1)
	Precision (%)	88	87	85	80
	Recall (%)	84	54	53	60
	F1-score (%)	51	78	65	68
	Execution time (s)	0.16	0.16	0.06	0.1
Average values	Accuracy (%)	85.83	93	93.5	87
	Precision (%)	88.65	97.16	97.16	90.5
	Recall (%)	96	91.50	92	93.16
	F1-score (%)	83.83	94	94	91.16
	Execution time (s)	0.18	0.006	0.06	0.14

presents the values for accuracy, precision, recall, F1-score, and execution time, along with the average values of these metrics.

Table 9. Metric average values.

	Accuracy (%)	Precision (%)	Recall (%)	Execution Time (s)	F1-Score
The proposed algorithm	97.33	98.66	97.5	0.47	98.2
SVM	85.33	88.65	96	0.18	83.83
DT	93	97.16	91.50	0.006	94
RF	93.50	97.16	92	0.06	94
KNN	87	90.50	93.16	0.14	91.16

collects all the average values of the three metrics for each of the proposed algorithms, as well as the SVM, DT, RF, and KNN algorithms.

From the table, it can be seen that the performance of the proposed algorithm is superior to the rest of the algorithms in terms of accuracy, precision, recall, and F1-score. Although the proposed algorithm is slower in fault detection compared to other algorithms, it remains suitable for industrial application and real-time operation.

Figure 17, Figure 18, Figure 19, Figure 20 and Figure 21 display the fault detection and diagnosis results using the proposed algorithm-based model and those based on the SVM, DT, RF, and KNN algorithms, respectively. It can be seen from these figures that the smallest number of incorrectly classified data are obtained in the case of both the RF algorithm-based model and the proposed algorithm-based model. The models fail to correctly classify all data due to data overlap and overfitting issues.

6. Conclusions

In this work, an enhanced approach was proposed for identifying and diagnosing PV array faults. A comparative study was conducted between the proposed algorithm-based model and models based on four statistical learning algorithms: SVM, DT, RF, and KNN. Unlike the decision tree algorithm, which uses the Gini index to split the data onto two classes, the proposed algorithm calculates Euclidean distances between an arbitrary point and the dataset samples. It then utilizes the minimal and maximal distances to separate the samples belonging to each class.

In this study, four features, namely, cell temperature, irradiance, and current and voltage of the maximum power point, were utilized. The proposed methodology effectively distinguishes the normal operating condition from other abnormal states, achieving a classification accuracy of 97%. The comparative investigation demonstrated that the proposed approach outperformed the other methods considered in this work in terms of accuracy, precision, recall, F1-score, and execution time.

By increasing the number of classifiers, the proposed technique can be easily extended to encompass additional faults.