Inheritance metrics feats in unsupervised learning to classify unlabeled datasets and clusters in fault prediction

Clustering methods

An approach where instances are grouped into a cluster is referred to as unsupervised learning. It is situated in the secondary category of data mining, whereas according to the classification, it is in the primary category of data mining. Since, classification utilizes labels of the class for training, whereas these labels do not utilize in the clustering rather attempt to find out the similarity among the features (Gan, Ma & Wu, 2007). Methods of clustering may be utilized to cluster classes with alike metrics through measuring distances or similarities. Subsequently to apply clustering methods, the average worth of all metrics contained by the cluster be able to examine besides the industrial thresholds of a metric. If the boundaries go beyond the value, the cluster could be categorized as faulty. The cluster analysis encompasses four fundamental points (Xu & Wunsch, 2005):

1. Selection of feature.

2. Selection of clustering algorithm.

3. Cluster validation. The clustering algorithm may produce numerous clusters, but these may not reveal the actual patterns situated in the data set. Thus, parameters of evaluation are essential to evaluate the algorithm efficiency.

4. Results Interpretation.

The grouping of clustering algorithms is not simple. The classification formed by Berkhin (2006) is shown in Table 1.

The above grouping may overlay, and some other scholars may generate diverse classes of these algorithms. Alternative grouping (Gan, Ma & Wu, 2007) is depicted in Table 2.

K-means

K-means is named Lloyd’s algorithm alternatively, mainly in the computer science community. It is common for the analysis of clustering in data mining. Its algorithm classifies entities in k clusters. The basic idea is to outline k centroids one for each cluster. The finest selection is to place these as farthest away from each other as feasible. The next step is to take every instance of the specified data set and correlate it by the adjacent cluster. Once all is done the first step is finished. After this, we need to compute again k new center of each cluster. After having a new center of k, we must assign points among the same datasets and adjacent to a new center. The midpoint of k amends its location gradually till then there are no variations exist or simply the midpoint is not rotating. Mostly, K-means is faster computationally as compared to hierarchical cluster and it creates clusters which are too nearer than the hierarchical cluster, particularly if the clusters are globular. The K-means is useful in data compression, data modeling, expression analysis, and other areas. The clustering process is explained as under:

1. The first step is to set the value of K—select quantity of clusters denoted as k.

2. The next step is Initialization—To select k initial position that is utilized as starting midpoint of a cluster.

3. Next step is classification—where mark every data point to the cluster that Euclidean distance is small among midpoint of cluster and point.

4. Next step is Centroid calculation—Once all point in the data set is assigned to a cluster, there is an essential process to again compute the new k midpoint (centroids).

5. Next step is convergence criteria—The steps of (iii) and (iv) are expected to be repeated until the midpoint (centroids) are not shifting.

The pseudo code of the algorithm is shown in Algorithm 1 (Gan, Ma & Wu, 2007). During the first phase of initialization, clusters are initialized randomly through the occurrences. Subsequent to this iteration phase where the assignment of instances is computed according to distances formula and then allocated to the nearest cluster. Distance is computed in-amongst the occurrence and the midpoint of the cluster. This phase iteratively performed until midpoint is not shifting furtherer.

Many distance functions are used in the literature some of them are listed as under:

1. Euclidean distance.

2. Manhattan distance.

3. City block distance.

Model evaluation metrics

In the SFP domain, diverse measurements to gauge the performance constructed from the confusion matrix are utilized to describe and assess the results of numerous techniques (He & Garcia, 2009; Wang & Yao, 2013; Arar & Ayan, 2015; Kumudha & Venkatesan, 2016). Table 3 demonstrates a conventional confusion matrix where the fault-prone and the fault-free are measured as positive and negative, respectively. The confusion matrix consists of four sections for binary classification which are the number of positive classes truly classified (TP), the number of falsely classified positive classes (FP), the number of falsely classified negative classes (FN), and the number of truly classified negative classes (TN) (Henein, Shawky & Abd-El-Hafiz, 2018).

In order to measure the proposed software fault prediction model, we consult the confusion matrix that appeared in Table 3, which is a key source for accuracy assessment in classification problems. Based on the confusion matrix, the following measures are utilized for appraisal (Alsawalqah et al., 2020):

1. Recall. Recall is the segment of applicable occurrences that are retrieved over the sum of applicable occurrences for example coverage rate. This may be described with the equation mentioned as under:

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

2. Precision: The Precision is a percentage of applicable occurrences amongst the retrieved occurrences. This may be described with the equation mentioned as under:

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

3. F1-measure. F1-measure is computed based on confusion matrix elements as mentioned above. F1-measure nearer to a means of the classifier has excellent performance prediction. This may be described with the equation mentioned as under:

   $$F1\text{-}measure={\displaystyle \frac{2\ast \left({\displaystyle \frac{TP}{TP+FP}x{\displaystyle \frac{TP}{TP+FN}}}\right)}{\left({\displaystyle \frac{TP}{TP+FP}+{\displaystyle \frac{TP}{TP+FN}}}\right)}}$$

4. Receiver Operating Characteristics Curve (ROC). The curve ROC demonstrates the trade-off between the false alarm rates (PF) and the probability of detection (PD). It is utilized to measure the performance of the classifier around altogether likely assessment thresholds. The range of area under the curve (AUC) is positioned within 1 and 0 (Bradley, 1997; Huang & Ling, 2005). It is equal to the probabilities of the arbitrarily selected example of the positive class that will have lesser predictable probabilities to be misclassified than an arbitrarily selected example of the negative class. A decent predictor may contain a higher value of AUC.

Metrics suite of C&K

The Chidamber & Kemerer metrics suite initially contains six metrics computed for each class, {noc, wmc, dit, cbo, lcom, rfc} (Aivosto, 2018). Each of them is briefly described in succeeding lines:

1. Weighted Methods Per Class (WMC). Regardless of the lengthy name of WMC, it is the counting of methods in the class.

   $$WMC=numberofmethodsdefinedinclass$$

   Retain WMC lower as a higher value is leading towards faultiest. One technique in which to bound the number of methods within a class to 20 or 50 approximately. An alternative technique where the utmost 10% of classes may contain more than twenty-four methods. So, this permits creating larger classes but most classes will be small.

2. Depth of Inheritance Tree (DIT). A class is as deep within the hierarchy contains extra variables and methods the class is likely to inherit, turn it into the further complex. Deep trees usually point toward major design complexity. On the other hand, taking a positive aspect, deeper trees encourage reusability as they inherit methods.

   $$DIT=maxinheritancepathfromclasstorootclass$$

   A higher value of DIT indicates the increase of faults so suggested DIT is five or less. Specifically, documentation of dot NET suggests that DIT be less than or equivalent to five as overly deep classes hierarchy is complicated to be developed. A few sources suggest the range up to eight.

3. Number of Children (NOC). NOC equal to the number of direct subclasses inherited from a base class. inheritance is not available in Visual Basic so the value of NOC is always 0.

   $$NOC=numberofimmediatesub-classesofaclass$$

   NOC calculates the width of a class hierarchy and DIT gauges the depth. Usually, depth is good as compared to width because it supports the method’s reusability by the use of inheritance. DIT and NOC are strongly correlated. The levels of Inheritance can be included to enhance the depth and decrease the width. The higher value of NOC shows a small number of faults. This might be due to higher reuse, which is usually desired.

4. Coupling between Object Classes (CBO). The classes are coupled where methods are defined within a class and use of these methods or instance variables declared by the other class. The utilization association can be in any direction: both uses and used-by relations are taken into consideration, but just once only.

   $$CBO=numberofclassestowhichaclassiscoupled$$

   A higher value of CBO is disadvantageous. Extreme coupling within object classes is damaging to modular design and avoids reusability. A higher value of coupling reveals fault-proneness. Thorough testing is therefore required. There is a question how high is excessively high? CBO less than fourteen is very high (Basili, Briand & Melo, 1996; Chidamber & Kemerer, 1994; Marinescu, 1998).

5. Response for a Class (RFC). Response for a class is a methods group that may be run in reply to receiving a message by a class object. RFC is the value of methods in the set.

   $$RFC=M+R(First-stepmeasure)$$where M = # of methods defined within a class and R = # of outside methods explicitly called by a class methods. As RFC precisely contains methods contacted via the remote class, so that it is a measurement of possible interaction among the methods of both classes. A larger value of RFC possibly has more faults. All classes which have a higher value of RFC are difficult to understand and more complex. Therefore, debugging and testing of classes are difficult.

6. Lack of Cohesion of Methods (LCOM). LOCOM or LCOM is a sixth metric in the suite of C&K metrics which is expressed as the lack of cohesion of methods. The computed process is described as under:

   $$LCOM1=P-Q,ifP>QLCOM=0otherwise$$

   Choose all sets of class methods, If these access disconnect groups of instance variables, add one in P. If these share at minimum one variable access, add one to Q. LCOM = 0 shows a cohesive class. LCOM > 0 shows the need a class or class might divide into two or more classes, as its variables are suitable in disconnect groups. A class having a higher value of LCOM be discovered to be faulty.

Inheritance metrics

1. Measure of Functional Abstraction (MFA). The MFA is a percentage of the number of inherited class methods to the number of methods accessible by class member methods (Chawla, 2013). Further explained as the average total classes in the design of the percentage of the number of methods inherited by a class to the sum of methods available to that class, for example, methods inherited and defined.

2. Inheritance Coupling (IC). The IC metric offers the amount of superclass with whom a child class is coupled. Usually, a class is coupled with the superclass in a case where at least one of his inherited methods functionally dependent on newly or re-defined class methods. Generally, a class is coupled with a superclass in the case where one clause in the following is fulfilled:

   1. At least one method which is inherited utilizes a data member or a variable that is declared within a redefined or new method.

   2. At least one method which is inherited communicates with a re-defined method.

   3. At least one method which is inherited is contacted by a re-defined method and utilizes a variable that is declared within the re-defined method.

Clustering

The use of unsupervised software fault prediction has been experimented with in the followings studies where numerous methods are utilized in the literature. Zhong, Khoshgoftaar & Seliya (2004) measure the algorithms natural-gas with the K-means algorithm to assess the performance of a cluster where the natural gas algorithm outperformed based on mean square error. Despite this, the technique needs a software specialist to decide about the software that is appropriate to categorize in the class of faulty or fault-free. Catal, Sevim & Diri (2009) employed clustering algorithm X-Means to find faulty or fault-free clusters applying certain software metrics as the splitting threshold. These metrics include cyclomatic complexity, operand, operator, and lines of code. The object of software is forecasted faulty in the case where the metric values are larger as compared to the threshold value, and conversely.

Bishnu & Bhattacherjee (2011) suggested the K-means algorithm based on quadtree and relate it to certain algorithms of clustering. His suggested algorithm’s error rates are rationally equivalent to Linear Discriminant Analysis, Naive Bayes, and K-means.

Abaei, Rezaei & Selamat (2013) put forward an algorithm self-organizing map for the clustering of software faults. In order to manage the label of the classes, they make use of the same threshold metrics which were utilized in the algorithm of X-Means clustering, recommended by Catal, Sevim & Diri (2009). The findings of their experiment depicted that the algorithm outclassed the algorithms of Catal, Sevim & Diri (2009) and Bishnu & Bhattacherjee (2011).

Nam & Kim (2015) suggested a threshold for clustering based on median-based partitioning. Every object having high values compared to the median is positioned in one cluster, on the other hand, all those objects are positioned in the second cluster. The elements in the upper half of the cluster are categorized as faulty, whereas the elements in the lower half of the cluster are grouped as fault-free. The suggested technique contains healthier results as compared to J48, Bayesian Network, Logistic Regression, Logistic Model Tree, Naive Bayes, Random Forest, and Support Vector Machine. Zhang et al. (2016) employed the spectral graph to build an unsupervised built on spectral classifier algorithm. The group of software objects with its connectivity depicts the edges and nodes of the spectral graph, respectively. They utilized the threshold of value zero to get the forecast faulty and fault-free clusters. In order to label entire cluster elements, they utilized the exploratory sums of row criterion. The findings of their experiment depicted that the classifier spectral performed much better as compared to logistic regression, random forest, logistic model tree, and Naive Bayes algorithms. Their advised technique is enhanced by Marjuni, Adji & Ferdiana (2019) to confirm the usage of spectral classifier needs, especially in the non-negative Laplacian graph matrix. They employed the absolute adjacency matrix to build the signed Laplacian graph matrix. The experimentation illustrations the usage of signed Laplacian on spectral classifier may expand both classification and cluster density.

Seliya & Khoshgoftaar (2007) suggested a constraint-based semi-supervised clustering scheme that utilizes clustering algorithm K-means as the fundamental algorithm aimed to handle this issue. The findings suggested that the employment of said approach superior as compared to their earlier prediction approach based on unsupervised learning. Nevertheless, the identification of a number for a cluster is until now a serious problem in this model and they have used an expert’s field knowledge in their approach to repetitively tag clusters as faulty or fault-free. Consequently, this model is also reliant on the competence of the expert.

Inheritance

Inheritance feature is infrequently focused in the research exclusively. In this regards important conclusions drawn in the research arena are explained in the followings lines.

In a study, literature is reviewed to find out the effectiveness of inheritance metrics in the fault prediction domain. The conclusions of the study indicate that about fifty-five inheritance metrics are formed up till now by the scholars where a couple of inheritance metrics are being utilized for fault prediction. Also, 79 public data sets were found, which encompass only ten inheritance metrics with many combinations. The use of Method-level metrics is sixty percent, and the same percentage is for the usage of private data sets. It is also identified that the utilization of machine learning approaches is growing, which used several performance measures. This study will help researchers to investigate the previous studies based on software metrics, their methods, various datasets, metrics of performance evaluation, and experiment results perspectives in an easy, and effective manner specifically consideration on the Inheritance viewpoint.

Similarly, inheritance metrics viability in software fault prediction is validated through the experiment. A total of 40 datasets having inheritance metrics are collected. After preprocessing, the selected data sets have been divided into all possible combinations of inheritance metrics followed by merging similar metrics. Resultantly, 67 data sets have been formed containing only inheritance metrics that have nominal binary class labels. SVM is used for model building and validation. Results based on error rate entropy advocate the viability of inheritance metrics in software fault prediction. Furthermore, {ic}, {noc}, {dit} are helpful in the reduction of error entropy rate overall 67 feature sets.

In another paper, examine in what way inheritance metrics contribute to predicting fault proneness in software. They have used 65 datasets with C&K and inheritance metrics to assess the influence of inheritance on software fault prediction. They divided the dataset into a dataset with inheritance and C&K and C&K minus inheritance for assessment of outcomes. Algorithm ANN is applied. Recall, Accuracy, F1 measures, TNR, and Precision are computed for gaging performance. Assessment is constructed and outcomes illustrations a satisfactory influence of inheritance metrics in software fault prediction. The testing community may securely employment inheritance metrics in forecasting faults in software. Furthermore, elevation in inheritance is unsuitable since it hypothetically leading towards faults in software.

Selection phase

This phase consists of picking and chooses of inheritance, C&K, and evaluation metrics along with finding a clustering algorithm. The selection of metrics is based on two conditions explained as follows:

• 1. Inheritance and C&K Metrics Selection. The elementary purpose of collection is to take a group of data that encompasses C&K and inheritance metrics, discussed briefly in section two. We merely pick out those metrics which abide by the following conditions.

• 2. Public Dataset. This condition is important to meet since the information of fault for software projects is exceptionally a lesser amount of reachable. The reason for this, the software fault data for enterprises or commercial projects are gathered in private software repositories whose availability is private. Alternatively, within a small software project’s fault data is insufficient. Consequently, marked data is infrequently accessible. The reachability of public data set will permit the assessment of the inheritance metrics in software fault prediction. Ultimately, 10 source data sets having C&K and inheritance metrics are discovered (Jureczko & Madeyski, 2010; Menzies & Di Stefano, 2004; Menzies et al., 2004; Softlab, 2019; Niu & Mahmoud, 2012; D’Ambros, Lanza & Robbes, 2010; Wagner, 2010; Abdelmoez, Goseva-Popstojanova & Ammar, 2006; Abdelmoez et al., 2005; Monarchi & Puhr, 1992; Shepperd et al., 2013). The two metrics of inheritance are the functional abstraction measure (mfa) and inheritance coupling (ic). The C&K metrics suite be made up of depth of the Inheritance Tree (dit), class-weighted method (wmc), number of children (noc), response for a class (rfc), coupling between objects (cbo), lack of cohesion in the methods (lcom).

• All ten data sets are situated on tera-PROMISE (Boetticher, 2007) and D’Ambros, Lanza & Robbes (2010) repositories. Table 4 displays the details of these datasets wherein column one displays the label of the source data set and version if existed. The number of instances in column two, the percentage of faults in column three, and the sum of metrics are displayed in column four. Overall, six metrics of C&K and two inheritance metrics are in these source data sets, where ✓ is indicated in the case where metric is appearing in the related source data set.

• Metrics are biasing towards correlation as these emphasize the associated features of Object Oriented here it is inheritance. A superior rate of correlation greater than equal to zero point seven or less than equal to minus zero point seven is a classification of duplication which must be excluded. In the study (Aziz, Khan & Nadeem, 2021) the Pearson r and the Spearman p correlation coefficient for the pairs discovered in public data sets are computed. The findings revealed that all combinations are positively correlated.

• 3. Evaluation Metrics. The classification models of machine learning are assessed using their accomplishment once categorizing the unidentified occurrences. The confusion matrix is a method to reveal the performance of the algorithm, Catal computed many metrics originated through the confusion matrix (Malhotra & Jain, 2012). Also, Malhotra et al. suggest a common explanation of numerous assessment measures utilized in software fault prediction. Conferring their judgments, TPR is the greatest frequently utilized assessment measure in software fault prediction, followed by Precision (Malhotra, 2015).

• The Accuracy shows the percentage of the sum of correct forecasts among the sum of correct and incorrect predictions. Precision signifies the share of correctly classified faulty classes across the sum of classified faulty classes. The recall is a ratio of correctly predicted faulty classes in-between entire real classes which are faults prone. F-measure is to quantify the Accuracy of an experiment. It involves Precision and Recall both in the experiment. F1-score is the harmonic mean of Recall and Precision where F1-score achieving the finest value at 1 (ideal Recall and Precision) and the poorest at the value 0.

• We selected TPR, Recall, Precision, F1-measure, and ROC to assess the model utilized within the paper.

• 4. Clustering Algorithm. K-means clustering is a form of unsupervised learning, that is used in the case of data without labels. The objective of this algorithm to find groups within data, where the number of groups denoted with variable k. Algorithm functions recursively to allocate every data instance to one of k clusters basis on the attributes which are imparted. Data marks are grouped basis on the attribute’s resemblance. The outcomes of the K-means algorithm are:

• (a) Clusters k centroids, that may be used to put a tag on newly created data.

• (b) The training data labels where all data points are allocated a distinct cluster.

• In particular, by describing sets before looking at the data, clustering allows to find and analyze naturally constructed sets. Each centroid of a cluster is a collection of attribute values that will be generated by the resulting groups. The study of the centroid element weights can be used to qualitatively determine the type of group for which each cluster is suitable.

Preprocessing phase

1. Eliminating Metrics. The source datasets comprise several metrics, for example, loc, ca, ce, I, and so on. Since our goal is to assess C&K and Inheritance metrics in the software fault prediction, thus all other metrics are dropped from the source datasets. This might affect the performance of fault prediction, nevertheless, it is to be expected to evaluate the effectiveness of inheritance metrics on software fault prediction.

2. Labels Uniformity. Every feature of source datasets have continuous values however discrepancy is located within the feature referred as BUG. That is solved with the followings rules.

   (1) $$BUG=\left\{\begin{array}{c}\mathrm{F}\mathrm{a}\mathrm{l}\mathrm{s}\mathrm{e}\mathrm{D}\mathrm{e}\mathrm{f}\mathrm{e}\mathrm{c}\mathrm{t}\mathrm{s}=0,\mathrm{N},\mathrm{N}\mathrm{o},\mathrm{F}\mathrm{A}\mathrm{L}\mathrm{S}\mathrm{E}\\ \mathrm{T}\mathrm{r}\mathrm{u}\mathrm{e}\mathrm{O}\mathrm{t}\mathrm{h}\mathrm{e}\mathrm{r}\mathrm{w}\mathrm{i}\mathrm{s}\mathrm{e}\end{array}\right\}$$

   Between this fault-free is described as FALSE and faulty is described as TRUE for all occurrences in the source data sets.

3. Splitting. Since our purpose is to measure the inheritance metrics effectiveness, so the source data set is split into two additional derived data sets namely Inheritance^+C&K and C&K. The derived dataset C&K comprises six metrics and the other derived data set Inheritance^+C&K comprises eight metrics. Conclusively, Table 5 is separated into two portions to display the figures of derived data sets which are created by splitting source datasets. The first column displays the data set name with the version if it exists. In succeeding columns six features of the first derived dataset C&K and eight features of derived dataset Inheritance^+CK where ✓ is indicated in the case where metric is appear in the associated datasets.

4. Data Normalization. Normalization is utilized to scale the attribute data to decreases in the range between minus one to one or zero to one. It is usually effective in classification algorithms. It is typically required when processing attributes on a varied scale, otherwise, it might lead to a reduction in the usefulness of a vital similarly crucial attribute (on a smaller scale) as other attributes holding values on the higher scale.

   Basically, in the situation of numerous attributes and these are having values on different scales, this might lead to poorer data models during employing data mining functions. Therefore, these are normalized to take each attribute on an equivalent scale. Techniques, for example, Min–Max, Z-Score, and Decimal scaling are being applied for the normalizing of data.

   In this experimentation, the Min–Max technique (Jain & Bhandare, 2011) is applied to normalize the data using the R function mmnorm. Min–Max normalization performs a linear conversion on the original data. Each of the actual data of attribute is mapped to a normalized value which lies in the range of 0 to 1. The Min–Max normalization is calculated by using the equation:

   $$Normalized(d)=(d{)}^{\prime }={\displaystyle \frac{d-min(P)}{max(p)-min(p)}}$$

   In the equation above, the min(p) and max(p) denote the minimum values and maximum values of the features, correspondingly.

Experiment phase

The particulars concerning experimentation setup are enlightened in the followings lines:

DATASET: 10 derived data sets respectively for C&K and Inheritance^+C&K, as displayed in Table 5.

TOOLS: Language R 3.4.3 (Rajnish & Bhattacherjee, 2005) in R Studio 1.1.383 (Rajnish & Bhattacherjee, 2006).

CLASSIFIERS: The utmost widespread method of unsupervised learning is the K-means algorithm for clustering. The key objective of this algorithm is to cluster alike data occurrences collectively and discover patterns in the said datasets. To accomplish this objective, this algorithm states the number of clusters denoted as (k) and after that collects the alike components into clusters. It begins by choosing the centroids, which is the initial point of the clusters. Subsequently, it allocates the occurrences to the neighboring centroids and afterward renews the locations of the centroids recursively till the centroids are stationary or the preset maximum times the iterations are reached.

A data set is given with (n) occurrences S = {a₁,a₂,…,a_n} in X^e, and an digit quantity (k), algorithm K-means intends to locate M = {c₁,c₂,…,c_n}, the collections of centroids on the basis of the error function mentioned as under:

$$E(C)=\sum _{x\in S^i=1,....k}min\parallel x-c_j{\parallel }^2$$

As stated earlier, K-means allocates occurrences to each of the defined clusters as per resemblance among them. In order to determine the resemblance, it typically applies the Euclidean distance amongst the occurrence and the centroids. K-means is applied on all 10 derived datasets of C&K and Inheritance^+C&K respectively as shown in Table 5. K-means applied using ClusterR 1.2.1 package of R language. We use the “Elkan” variant of K-means. The reason for selection is that it uses the triangle inequality to efficiently map the data with well-defined clusters. However, the algorithms have relatively higher space complexity. Since we are interested in the binary classes of SFP, we initialize the value of k as 2. The initial centroid is determined randomly in 100 different initializations to avoid biases. Moreover, we performed 300 iterations with tolerance as low as 0.0001. Finally, the quality of clusters is measured in terms of the Silhouette Score. A clustering process is applied on both the derived datasets denoted as C&K and inheritance^+C&K as displayed in Table 5 to group its instances into clusters based on their similarity. We begin by grouping instances into two groups of clusters. We use the K-means algorithm as the most popular clustering technique. The centroids of all the metrics are recorded for both C&K and inheritance^+C&K datasets.

Computation phase

After applying the K-means algorithm on 10 datasets each of C&K and Inheritance^+C&K further activities includes the computation of various elements of the experiment. Firstly, distance needs to be calculated through the Euclidean distance formula. Secondly, identification of cluster being faulty or fault-free and lastly computation of performance measure to draw findings out of this experiment. These activities are explained subsequently in the following lines as under:

1. Computation of Distance. The first activity to compute the distance of each instance to identify which instance fall in which cluster. Therefore distance of each instance is computed for C&K and Inheritance^+C&K datasets through the following Euclidean distance formula.

   $$d(p,q)=\sqrt{{(q_1-p_1)}^2+{(q_2-p_2)}^2+...+{(q_n-p_n)}^2}$$

   where p, q are two points in Euclidean n-space. q_i, p_i are euclidean vectors, starting from the origin of the space(initial points) and n = n-space.

2. Identification of Clusters. The next step is to identify a cluster as faulty or faulty free. In this regard, the average is taken to all the metrics of a cluster. Resultantly, the larger value declared as the faulty and smaller value of average is considered as fault-free. The process follows the following formula:

   (2) $$f(C_{1,2})=\left\{\begin{array}{c}\mathrm{F}\mathrm{a}\mathrm{u}\mathrm{l}\mathrm{t}\mathrm{y}\\ \mathrm{M}\mathrm{a}\mathrm{x}(\frac{\sum _{i=1}^{n}value(M_i,C_1)}{\parallel M\parallel },\frac{\sum _{i=1}^{n}value(Mi,C_2)}{\parallel M\parallel })\\ \mathrm{F}\mathrm{a}\mathrm{u}\mathrm{l}\mathrm{t}\mathrm{F}\mathrm{r}\mathrm{e}\mathrm{e}\mathrm{O}\mathrm{t}\mathrm{h}\mathrm{e}\mathrm{r}\mathrm{w}\mathrm{i}\mathrm{s}\mathrm{e}\end{array}\right\}$$

   where C referring cluster 1 and 2, M represent metrics, and ∥M∥ represent the cardinality of metrics in the formula.

   In the experiment, the C&K dataset has ∥M∥ of C&K dataset is six and Inheritance^+C&K has eight. Each dataset has two clusters. So, after applying the above-mentioned formula the Table 6 shows the results. The first column shows the name of the base dataset, the second column shows the predicted cluster as 0 fault-free and 1 as faulty. Column 3–8 the centroids values of respective metrics of the C&K dataset and column 9 shows the average for the first cluster in the first row and the average of the second cluster in the next row against each base dataset. Similarly, column 10–17 shows the centroids values and in column 18 average of clusters one and two in first and a subsequent row of the base dataset for Inheritance^+C&K.

   Findings revealed that the Inheritance^+C&K has correctly classified the faulty and fault free clusters but C&K has not correctly classified clusters of serapion and synapse-1.0 datasets.

3. Computation of Performance Measures. All ten data sets displayed in Table 5 have been utilized for model construction and authenticating K-means clustering. Model construction of K-means is accomplished employing ClusterR 1.2.1 package of R 3.4.3 language. K-means is applied on both the datasets and TPR, Precision, Recall, F1-score, ROC, and percentage of corrected classified instances are computed for C&K and Inheritance^+C&K datasets. Accumulative findings are presented in Table 7.

Results/comparison phase

The utmost significant objective of this paper is experimentation and to validate the effectiveness of inheritance metrics to classify unlabeled datasets employing unsupervised learning model K-means clustering, whereas the subsidiary purpose is to attain the best findings of the algorithms of machine learning. In addition, identification of clusters as faulty or fault-free is also a part of this paper. So that is why we have exactly filtered data sets and designed the experiments. Table 7 demonstrates the scores of the experiments in which TPR, Precision, Recall, F1-score, and ROC are computed for 10 data sets of C&K and Inheritance^+C&K.

In this regards, Fig. 3 graphically compares the performance differences of K-means in C&K and Inheritance^+C&K through evaluation parameters of TPR, Precision, Recall, F1-Measure and ROC which reveal that Inheritance^+C&K has superior results overall.

TPR assessment of Inheritance^+CK and C&K is shown in Fig. 3A where eight times Inheritance^+CK has better results while in two cases C&K is superior.

In case of Precision, Fig. 3B depicts that six times Inheritance^+CK has better results while in four cases C&K is superior.

In case of Recall, Fig. 3C depicts that eight times Inheritance^+CK has better results while in two cases C&K has superior results.

In case of F1-Measure, Fig. 3D depicts that nine times Inheritance^+CK has better results while in only one case C&K has superior result.

In case of ROC, Fig. 3E depicts that six times Inheritance^+CK has better results while in four cases C&K has superior results.

Figure 4 indicates the non-existence of outliers in the findings throughout all the datasets. So it can thus be safely acknowledged that the means of performance methods are not prejudiced. Therefore revealed performance of Inheritance^+CK metrics predominates.

In order to do further validation of the effectiveness of inheritance in software fault prediction using unlabeled data, the following evaluations are carried out among both the data sets.

One-one comparison

Outcomes of the experimentation comprising TRR, Precision, Recall, F1-score, and ROC are displayed in Table 7 for Inheritance^+C&K and C&K data sets. So, to make line-wise assessment, the values of evaluation metrics of both the data sets are equate to determine the larger values. The findings are condensed in Table 8 which demonstrates that:

Table 8:

One to one comparison.

Group	TP rate	Precision	Recall	F-measure	ROC area
Inheritance+C&K (#)	8	8	8	9	6
C&K (#)	2	3	2	1	4
Inheritance+C&K (%)	80	73	80	90	60
C&K (%)	20	27	20	10	40

DOI: 10.7717/peerj-cs.722/table-8

1. The F1-measure shows that inheritance^+C&K has superior results in 9 datasets whereas C&K is superior in only one dataset. So Inheritance^+CK attained 90% of total datasets as compare to 10% for C&K.

2. TRR, Precision, and Recall showed inheritance^+C&K has superior results in 8 datasets whereas C&K is superior in 2 datasets. So inheritance^+C&K attained 80% of total datasets as compare to 20% for C&K.

3. Precision displayed that the inheritance^+C&K retains better scores in 8 data sets and C&K is better in 3 datasets. Therefore Inheritance^+C&K achieved 73% overall as making a comparison with C&K which achieved 27% overall.

4. The ROC indicates inheritance^+C&K possesses better scores in 6 data sets while C&K is better in 4 data sets. Thus Inheritance^+C&K achieved 60% of overall data sets as making a comparison with C&K which achieved 40%.

Basing on ten datasets, Inheritance^+C&K datasets have better scores to making the one-to-one comparison with C&K for TRR, Precision, Recall, F1-score, and ROC. The finds are depicted graphically in Fig. 5.

Comparison of correct classification

Mostly C&K metrics suit is regarded as superior performer in software fault prediction domain. Thus to determine inheritance metrics will be beneficial to correctly classified instances or otherwise. In this regards, K-means clustering is applied on 10 selected datasets which are split into Inheritance^+C&K and C&K datasets as displayed in Table 5 and score of evaluation metrics are depicted in Table 7. The findings are summarized in Table 9 which are:

Table 9:

Comparison of correct classification.

Datasets	Inheritance+C&K	C&K
	Correctly classified (%)	Correctly classified (%)
ant-1.7	56	54
e-learning	59.38	50.00
iny-1.1	52.25	51.35
nieruchomosci	74.07	62.96
poi-1.5	67.09	52.32
serapion	75.56	73.33
synapse-1.0	63.06	60.51
szybkafucha	76	72
tomcat	60.13	58.25
xalan-2.7	60.13	51.63

DOI: 10.7717/peerj-cs.722/table-9

1. All percentage depicted that Inheritance^+C&K datasets have superior results in all 10 datasets as compare to C&K datasets.

2. Min and Max percentage of the correctly classified instance are 52–76% by Inheritance^+C&K whereas 50–73% by C&K dataset in all 10 base datasets.

3. The difference between Inheritance^+C&K and C&K is 2% to 15% respectively in all 10 base datasets.

Basing on to all 10 datasets, Inheritance^+C&K datasets achieved significantly better than C&K dataset to correctly classified instances. The results are displayed graphically in Fig. 6.