Software Defect Prediction Model Research Articles

Hybrid model with optimization tactics for software defect prediction

Defects are frequent in software systems, and they can cause a lot of issues for users. Despite the fact that many studies have been conducted on employing software product metrics to determine defect-prone modules, defect prediction techniques are still worth investigating. Hence, the aim of this work is to provide a unique Software Defect Prediction (SDP) approach that includes four steps like “(a) pre-processing, (b) feature extraction, (c) feature selection and (d) detection.” At first, the input data are given to the pre-processing step, as well as in the feature extraction step; the “statistical features, raw features, higher-order statistical features as well as proposed entropy features” are extracted from the pre-processed data. In addition, the retrieved features are sent into a feature selection step, wherein the appropriate features are selected utilizing a modified chi-square scheme. In the detection step, a hybrid Long Short-Term Memory (LSTM) and Deep Belief Network (DBN) classifiers are used to predict the defects. To provide a more accurate detection, the weights of both DBN and LSTM are optimally tuned via a Self Improved Social Ski-Driver Optimization (SISSDO) algorithm. This proposed SDP model is a beneficial practice for enhancing software quality and reliability. Moreover, the results of the adopted technique are assessed to traditional techniques on the basis of various measures. In particular, the accuracy of the suggested approach for dataset 3 is 5.80%, 6.52%, 5.07%, 7.97%, 5.80%, 9.42%, 9.42%, 10.15%, 2.17%, and 3.62% better than the extant HC[Formula: see text]+[Formula: see text]ALO, HC[Formula: see text]+[Formula: see text]SMO, HC[Formula: see text]+[Formula: see text]CMBO, HC[Formula: see text]+[Formula: see text]SSD, RNN, CNN, NN, Bi-LSTM, HC+SPFCNN, and HC[Formula: see text]+[Formula: see text]CWAR approaches, correspondingly. Moreover, the computation time of the suggested approach is 17.05%, 5.78%, 1.31%, and 50.53% better than the existing HC[Formula: see text]+[Formula: see text]ALO, HC[Formula: see text]+[Formula: see text]SMO, HC[Formula: see text]+[Formula: see text]CMBO, and HC[Formula: see text]+[Formula: see text]SSD approaches, correspondingly.

An improved software defect prediction model based on grey incidence analysis and Naive Bayes algorithm

This paper aims to improve the accuracy of software defect prediction by using a prediction model based on grey incidence analysis and Naive Bayes algorithm. The model employs the Naïve Bayes as the basic classifier of the software defect prediction model. The grey incidence analysis is used to analyze the relation between software modules and ideal modules. Then, the grey correlation degree is embedded into the Naive Bayes classification model as a feature attribute. According to the comparison and analysis of NASA’s public dataset, the prediction model in this paper improves the prediction accuracy.

Cloud-based bug tracking software defects analysis using deep learning

Cloud technology is not immune to bugs and issue tracking. A dedicated system is required that will extremely error prone and less cumbersome and must command a high degree of collaboration, flexibility of operations and smart decision making. One of the primary goals of software engineering is to provide high-quality software within a specified budget and period for cloud-based technology. However, defects found in Cloud-Based Bug Tracking software’s can result in quality reduction as well as delay in the delivery process. Therefore, software testing plays a vital role in ensuring the quality of software in the cloud, but software testing requires higher time and cost with the increase of complexity of user requirements. This issue is even cumbersome in the embedded software design. Early detection of defect-prone components in general and embedded software helps to recognize which components require higher attention during testing and thereby allocate the available resources effectively and efficiently. This research was motivated by the demand of minimizing the time and cost required for Cloud-Based Bug Tracking Software testing for both embedded and general-purpose software while ensuring the delivery of high-quality software products without any delays emanating from the cloud. Not withstanding that several machine learning techniques have been widely applied for building software defect prediction models in general, achieving higher prediction accuracy is still a challenging task. Thus, the primary aim of this research is to investigate how deep learning methods can be used for Cloud-Based Bug Tracking Software defect detection with a higher accuracy. The research conducted an experiment with four different configurations of Multi-Layer Perceptron neural network using five publicly available software defect datasets. Results of the experiments show that the best possible network configuration for software defect detection model using Multi-Layer Perceptron can be the prediction model with two hidden layers having 25 neurons in the first hidden layer and 5 neurons in the second hidden layer.

Prediction of software defects by knowledge graph and genetic algorithm

Software defect detection is one of the biggest software development challenges and accounts for the largest budget in the software development process. One of the effective activities for software development and increasing its reliability is to predict software defects before reaching the test stage, which helps to save time in the production, maintenance and cost process. This research aims to present a software defect prediction method based on knowledge graphs and automated machine learning. We use knowledge acquisition, knowledge fusion, knowledge storage and knowledge calculation and other knowledge map construction technology research, to realize the knowledge map recommends high-quality software defect prediction models as the hot-start input conditions for automatic search. The empirical study uses NASA's open-source dataset experimental objects and six performance evaluation indicators include Precision, Recall, PRC (Precision Recall Characteristic), ROC (Receiver Operating Characteristic), F-Measure, MCC (Matthews Correlation Coefficient). The experimental results show that the proposed model performs better than the traditional classic software defect prediction model recommended by the knowledge map in terms of different datasets and evaluation indicators

Comparisons of Filter, Wrapper and Embedded-Based Feature Selection Techniques for Consistency of Software Metrics Analysis

Identifying and selecting the most consistent subset of metrics which improves the performance of software defect prediction model is paramount but challenging problem as it receives little attention in literature. The current research aimed at investigating the consistency of subsets of metrics that are produced by embedded feature selection techniques. Ten (10) feature selection techniques used from the families of filter and wrapper-based feature selection techniques commonly used in the defect prediction domain. Ten (10) publicly available defect datasets were studied which span both proprietary and open source domains. SVM-RFE-RF presented 42-93% consistent metrics across datasets. While the prior study on non-Embedded produced 56.5% consistent metrics at median. SVM-RFE-LF approach of Embedded Feature Selection Technique produced 54-80% consistent metrics across datasets and 42.5% at median. To state the purpose of tittle has been achieved Embedded based Feature Selection Techniques produced most efficient consistent subset selection across the entire datasets and amongst the feature selection techniques as compared with counterpart filter and wrapper-based feature selection techniques

An Optimized Feature Selection Method Using Ensemble Classifiers in Software Defect Prediction for Healthcare Systems

The healthcare systems are extensively being used with increased focus on safety of patients. Software engineering for healthcare applications is an emerging research area. Detecting defects is a critical step of software development process of healthcare applications. The performance of the Software Defect Prediction model (SDP) depends on the features of healthcare system; irrelevant features decrease the performance of the model. An optimized feature selection technique is needed to recognize and remove the irrelevant features. In this study, a new optimized feature selection technique, i.e., multiobjective Harris Hawk Optimization (HHO), is proposed for binary classification problem with Adaptive Synthetic Sampling (ADASYN) Technique. Multiobjective HHO is proposed with two main objectives, one to reduce the total amount of selected features and the other to maximize the performance of the proposed model. The multiobjective feature selection technique helps to find the optimal solution to achieve the desired objectives and increase the classification performance in terms of accuracy, AUC, precision, recall, and F1-measure. The study conducts an experiment on a healthcare dataset. Six different search techniques (RF, SVM, bagging, adaptive boosting, voting, and stacking) are implemented on the dataset. The proposed model helps to predict the software defects with a significant classification accuracy of 0.990 and AUC score of 0.992.

Machine Learning-Based False Positive Software Vulnerability Analysis

Measurements and fault data from an older software version were used to build the fault prediction model for the new release. When past fault data isn't available, it's a problem. The software industry's assessment of programme module failure rates without fault labels is a difficult task. Unsupervised learning can be used to build a software fault prediction model when module defect labels are not available. These techniques can help identify programme modules that are more prone to errors. One method is to make use of clustering algorithms. Software module failures can be predicted using unsupervised techniques such as clustering when fault labels are not available. Machine learning clustering-based software failure prediction is our approach to solving this complex problem.

A Survey of Different Approaches for the Class Imbalance Problem in Software Defect Prediction

The imbalanced nature of the software datasets leads to the biased learning of prediction model toward the observations of the majority class (non-defective class). The prediction model can produce poor results for the minority class observations. Such misappropriations can prove costly especially in software development where minority class (defective) is the one that has the highest interest from the learning point of view. Various approaches have been used for dealing with class imbalance problem of software defect prediction but no one dominates and hence developing a generalized software defect prediction model for imbalanced datasets remains problematic. This paper surveys existing approaches for handling class imbalance problem of software defect datasets. In this survey, most relevant software defect prediction studies and identified the two main approaches that have been used for handling imbalance issue of software defect datasets. Furthermore, we also provide some comparison of findings in state-of-the-art literature and the guidelines for carrying out future research.

An Unsupervised Software Fault Prediction Approach Using Threshold Derivation

Software fault prediction models help the software quality assurance team to manage the resources optimally during software maintenance. Most of the recently proposed fault prediction approaches are helpful on labeled datasets only. Recently, several threshold-based software fault prediction approaches have been proposed. However, these approaches do not incorporate the distribution of software metrics for metric threshold derivation; hence, they demonstrate poor performance. To fill this gap, we develop an automated fault prediction approach, namely threshold clustering labeling/threshold clustering labeling plus (TCLP), which does not need a labeled dataset. It can identify the faulty and nonfaulty artifacts on unlabeled datasets by self-learning. Our proposed approach is an extension of the state-of-the-art technique known as CLAMI. Unlike CLAMI, we derive the metrics threshold using logarithmic transformation. Thereafter, we label the instances into binary classes (faulty/nonfaulty) using the metric threshold values. TCLP extends this approach one step further by performing fault prediction using a random forest algorithm. The empirical evaluation of the proposed approach on 28 datasets (with the different number of metrics and granularity) collected from five software groups shows that the proposed unsupervised method obtains significantly better results than those of the state-of-the-art methods. The proposed approach impressively enhances the performance of CLAMI in terms of accuracy, F-measure, and Mathew’s correlation coefficient.

Generative Oversampling Methods for Handling Imbalanced Data in Software Fault Prediction

Imbalanced software fault datasets, having fewer faulty modules than the nonfaulty modules, make accurate fault prediction difficult. It is challenging for software practitioners to handle imbalanced fault data during software fault prediction (SFP). Earlier, several researchers have applied oversampling techniques such as synthetic minority oversampling techniques and others for imbalanced learning in SFP. However, most of these techniques resulted in overfitted prediction models. This article presents generative oversampling methods to handle imbalanced data problems in the SFP. Using the generative adversarial network (GAN) based approach, the presented methods generate synthetic samples of the faulty modules to balance the proportion of faulty and nonfaulty modules in the fault datasets. Further, SFP models are built on the processed fault datasets using different machine learning techniques. Experimental validation of the presented oversampling methods is done on 18 fault datasets gathered from PROMISE, JIRA, Eclipse data repositories, and precision, recall, f1-score, and AUC are used as evaluation measures. We extensively compared presented oversampling methods with various state-of-the-art class imbalance techniques and baseline models. The experimental results evidenced that the presented methods improved fault prediction performance and yielded better performance than the state-of-the-art class imbalance techniques.

Predicting defects in imbalanced data using resampling methods: an empirical investigation.

The development of correct and effective software defect prediction (SDP) models is one of the utmost needs of the software industry. Statistics of many defect-related open-source data sets depict the class imbalance problem in object-oriented projects. Models trained on imbalanced data leads to inaccurate future predictions owing to biased learning and ineffective defect prediction. In addition to this large number of software metrics degrades the model performance. This study aims at (1) identification of useful metrics in the software using correlation feature selection, (2) extensive comparative analysis of 10 resampling methods to generate effective machine learning models for imbalanced data, (3) inclusion of stable performance evaluators—AUC, GMean, and Balance and (4) integration of statistical validation of results. The impact of 10 resampling methods is analyzed on selected features of 12 object-oriented Apache datasets using 15 machine learning techniques. The performances of developed models are analyzed using AUC, GMean, Balance, and sensitivity. Statistical results advocate the use of resampling methods to improve SDP. Random oversampling portrays the best predictive capability of developed defect prediction models. The study provides a guideline for identifying metrics that are influential for SDP. The performances of oversampling methods are superior to undersampling methods.

A Software Defect Prediction Approach Based on BiGAN Anomaly Detection

Software defect prediction usually is regarded as a classification problem, but classification models will face the class imbalance problem. Although there are many methods to solve the class imbalance problem, there is no method that can fundamentally solve the problem currently. In addition, supervised learning algorithms are always used to train defect prediction models, but obtaining a large amount of high-quality labelled data requires a lot of time and labor cost. In order to solve the class imbalance problem and eliminate the disadvantage of supervised learning, this paper attempts to predict software defects from a new perspective of anomaly detection. We propose an Anomaly Detection Model Based on BiGAN for Software Defect Prediction (ADGAN-SDP). The model proposed in this paper not only does not need to consider the class imbalance problem but also uses a semi-supervised method to train the model. Eight classification-based software defect prediction models are used as the baseline models and compared with ADGAN-SDP model. We evaluate ADGAN-SDP on 19 projects from NASA, AEEEM, and ReLink repositories. The experimental results show that the ADGAN-SDP model, which has a higher recall, outperforms all baseline models. It is suggested that the anomaly detection approach can be applied to the software defect prediction to fundamentally solve the class imbalance problem.

Software Quality Prediction Using Machine Learning

With the emergence of Machine Learning, many companies are increasingly embracing this revolutionary approach, both in terms of growth and maintenance, to reduce software costs. This research aimed at building two models which is Software Defect Prediction Model (SDPM) which will be used to predict defects in software and Software Maintainability Prediction Model (SMPM) which will be used for Software Maintainability. Different classifiers, namely Random Forest, Decision Tree, Naïve Bayes and Artificial Neural Networks have been considered and then evaluated using different metrics such as Accuracy, Precision, Recall and Area Under the Curve (AUC). The two models have successfully been evaluated and Decision Tree has been chosen as compared to other classifiers which tends to perform much better. Finally a framework based on a set of guidelines that can be used to improve software quality has been devised.

Machine Learning-Based Software Defect Prediction for Mobile Applications: A Systematic Literature Review.

Software defect prediction studies aim to predict defect-prone components before the testing stage of the software development process. The main benefit of these prediction models is that more testing resources can be allocated to fault-prone modules effectively. While a few software defect prediction models have been developed for mobile applications, a systematic overview of these studies is still missing. Therefore, we carried out a Systematic Literature Review (SLR) study to evaluate how machine learning has been applied to predict faults in mobile applications. This study defined nine research questions, and 47 relevant studies were selected from scientific databases to respond to these research questions. Results show that most studies focused on Android applications (i.e., 48%), supervised machine learning has been applied in most studies (i.e., 92%), and object-oriented metrics were mainly preferred. The top five most preferred machine learning algorithms are Naïve Bayes, Support Vector Machines, Logistic Regression, Artificial Neural Networks, and Decision Trees. Researchers mostly preferred Object-Oriented metrics. Only a few studies applied deep learning algorithms including Long Short-Term Memory (LSTM), Deep Belief Networks (DBN), and Deep Neural Networks (DNN). This is the first study that systematically reviews software defect prediction research focused on mobile applications. It will pave the way for further research in mobile software fault prediction and help both researchers and practitioners in this field.

Impact of Unbalanced Classification on the Performance of Software Defect Prediction Models

Objectives: To propose a suitable imbalanced data classification model to split the dataset into two new datasets and to test the created imbalanced dataset by the prediction models. Methods: The imbalance defect data sets are taken from the PROMISE library and used for the performance evaluation. The results clearly demonstrate that the performance of three existing prediction classifier models, K-Nearest Neighbor (KNN), Naive Bayes (NB), and Back Propagation (BPN), is very susceptible in terms of unbalance of classification, while Support Vector Machine (SVM) and Extreme Learning Machine (ELM) are more stable. Findings: The outcome of this research reveals that applied SVM and ELM machine learning models improves the performance in defect prediction and records 29% more than KNN, and 19% more than NB and BPN. Novelty: According to the findings of a comprehensive study, the proposed machine learning new classification imbalance impact analysis method outperforms the existing ones in order to transform the original imbalance data set into a new data set with an increasing imbalance rate and be able to select models to evaluate different predictions on the new data set. Keywords: Software Fault Prediction Model; Imbalance Problem Classification; Artificial Intelligence; Smart Debugging; Unbalanced Classification

Interpretability application of the Just-in-Time software defect prediction model

Software defect prediction is one of the most active fields in software engineering. Recently, some experts have proposed the Just-in-time Defect Prediction Technology. Just-in-time Defect prediction technology has become a hot topic in defect prediction due to its directness and fine granularity. This technique can predict whether a software defect exists in every code change submitted by a developer. In addition, the method has the advantages of high speed and easy tracking. However, the biggest challenge is that the prediction accuracy of Just-in-Time software is affected by the data set category imbalance. In most cases, 20% of defects in software engineering may be in 80% of modules, and code changes that do not cause defects account for a large proportion. Therefore, there is an imbalance in the data set, that is, the imbalance between a few classes and a majority of classes, which will affect the classification prediction effect of the model. Furthermore, because most features do not result in code changes that cause defects, it is not easy to achieve the desired results in practice even though the model is highly predictive. In addition, the features of the data set contain many irrelevant features and redundant features, which are invalid data, which will increase the complexity of the prediction model and reduce the prediction efficiency. To improve the prediction efficiency of Just-in-Time defect prediction technology. We trained a just-in-time defect prediction model using six open source projects from different fields based on random forest classification. LIME Interpretability technique is used to explain the model to a certain extent. By using explicable methods to extract meaningful, relevant features, the experiment can only need 45% of the original work to explain the prediction results of the prediction model and identify critical features through explicable techniques, and only need 96% of the original work to achieve this goal, under the premise of ensuring specific prediction effects. Therefore, the application of interpretable techniques can significantly reduce the workload of developers and improve work efficiency.

Towards Design and Feasibility Analysis of DePaaS: AI Based Global Unified Software Defect Prediction Framework

Using artificial intelligence (AI) based software defect prediction (SDP) techniques in the software development process helps isolate defective software modules, count the number of software defects, and identify risky code changes. However, software development teams are unaware of SDP and do not have easy access to relevant models and techniques. The major reason for this problem seems to be the fragmentation of SDP research and SDP practice. To unify SDP research and practice this article introduces a cloud-based, global, unified AI framework for SDP called DePaaS—Defects Prediction as a Service. The article describes the usage context, use cases and detailed architecture of DePaaS and presents the first response of the industry practitioners to DePaaS. In a first of its kind survey, the article captures practitioner’s belief into SDP and ability of DePaaS to solve some of the known challenges of the field of software defect prediction. This article also provides a novel process for SDP, detailed description of the structure and behaviour of DePaaS architecture components, six best SDP models offered by DePaaS, a description of algorithms that recommend SDP models, feature sets and tunable parameters, and a rich set of challenges to build, use and sustain DePaaS. With the contributions of this article, SDP research and practice could be unified enabling building and using more pragmatic defect prediction models leading to increase in the efficiency of software testing.

Cross-Project Defect Prediction: A Literature Review

Background: Software defect prediction models aim at identifying the potential faulty modules of a software project based on historical data collected from previous versions of the same project. Due to the lack of availability of software engineering data from the same project, the researchers proposed cross-project defect prediction (CPDP) models where the data collected from one or more projects are used to predict faults in other project. There are a number of approaches proposed with different levels of success and very limited repeatability. Goals: The purpose of this paper is to investigate the existing studies of cross-project models for defect prediction. It synthesizes the literature focusing on characteristics such as project type, software metrics, data preprocessing techniques, features selection approaches, classifiers, and performance measures used. Method: This paper follows the well-known Systematic Literature Review (SLR) approach proposed by Barbara Kitchenham in 2007. Results: Our finding shows that most of the article was published between 2015 and 2021. Moreover, the studies are mostly based on open-source datasets and the software metrics used to create the models are mainly product metrics. We also found out that most studies attempted to improve their models improving data preprocessing and feature selection approaches. Furthermore, logistic regression followed by naive bayes and random forest are the most adopted classifier techniques in such models. Finally, the f-measure followed by recall and AUC are the most preferred evaluation measure used to evaluate the performance of the models. Conclusions: This study provides an overview of the different approaches used to improve the CPDP models analyzing the different techniques used for data preprocessing, feature selection, and the selection of the classifiers. Moreover, we identified some aspects that need further investigation.

Compiler IR-Based Program Encoding Method for Software Defect Prediction

With the continuous expansion of software applications, people's requirements for software quality are increasing. Software defect prediction is an important technology to improve software quality. It often encodes the software into several features and applies the machine learning method to build defect prediction classifiers, which can estimate the software areas is clean or buggy. However, the current encoding methods are mainly based on the traditional manual features or the AST of source code. Traditional manual features are difficult to reflect the deep semantics of programs, and there is a lot of noise information in AST, which affects the expression of semantic features. To overcome the above deficiencies, we combined with the Convolutional Neural Networks (CNN) and proposed a novel compiler Intermediate Representation (IR) based program encoding method for software defect prediction (CIR-CNN). Specifically, our program encoding method is based on the compiler IR, which can eliminate a large amount of noise information in the syntax structure of the source code and facilitate the acquisition of more accurate semantic information. Secondly, with the help of data flow analysis, a Data Dependency Graph (DDG) is constructed on the compiler IR, which helps to capture the deeper semantic information of the program. Finally, we use the widely used CNN model to build a software defect prediction model, which can increase the adaptive ability of the method. To evaluate the performance of the CIR-CNN, we use seven projects from PROMISE datasets to set up comparative experiments. The experiments results show that, in WPDP, with our CIR-CNN method, the prediction accuracy was improved by 12% for the AST-encoded CNN-based model and by 20.9% for the traditional features-based LR model, respectively. And in CPDP, the AST-encoded DBN-based model was improved by 9.1% and the traditional features-based TCA+ model by 19.2%, respectively.

An Optimized Software Defect Prediction Model Based on PSO - ANFIS

Introduction : The Software defect prediction (SDP) model plays a very important role in today’s software industry. SDP models can provide either only a list of defect-prone classes as output or the number of defects present in each class. This output can then be used by quality assurance teams to effectively allocate limited resources for validating software products by putting more effort into these defect-prone classes.The study proposes an OANFIS-SDP model that gives the number of defects as an output to software development teams. Development teams can then use this data for better allocation for their scares resources such as time and manpower. Method: OANFIS is a novel approach based on the Adaptive neuro-fuzzy inference system (ANFIS), which is optimized using Particle swarm optimization (PSO). OANFIS model combines the flexibility of ANFIS model with the optimization capabilities of PSO for better performance. Results: The proposed model is tested using the dataset from open source java projects of varied sizes (from 176 to 745 classes). Conclusion: The study proposes an SDP model based OANFIS that gives the number of defects as an output to software development teams. Development teams can then use this data for better allocation for their scares resources such as time and manpower. OANFIS is a novel approach that uses the flexibility provided by the ANFIS model and optimizes the same using PSO. The results given by OANFIS are very good and it can also be concluded that the performance of the SDP model based on OANFIS might be influenced by the size of projects. Discussion: The performance of the SDP model based on OANFIS is better than the ANFIS model. It can also be concluded that the performance of the SDP model might be influenced by the size of projects.