Explainable AI-Driven Metrics for Transparent Software Quality Prediction

Software Quality Assessment Using Explainable Machine Learning

This research proposes an Explainable Machine Learning (XML)–based framework to assess software quality by integrating code metrics, defect datasets, and advanced interpretability methods such as SHAP, LIME, and permutation importance.

Automated software debugging and bug prediction through the use of machine learning and deep learning

An Explainable Feature Selection and Stacking Ensemble Framework for Software Fault Prediction

The increasing complexity of contemporary software systems makes accurate and interpretable software fault prediction a challenging task. Although ensemble learning techniques have demonstrated promising predictive performance, existing approaches continue to face challenges related to feature selection, cross-project consistency, and model interpretability. This study proposes a Hybrid Boosted Stacking Ensemble Framework (HBSEF) for software fault prediction that integrates hybrid feature selection, ensemble learning, statistical validation, and SHAP-based interpretability. The proposed framework incorporates data preprocessing, class-imbalance handling using Random Oversampling, and a hybrid feature selection strategy integrating filter, embedded, and wrapper methods to identify software metrics with consistent predictive importance across multiple software projects. The core predictive model employs CatBoost, XGBoost, and LightGBM as base learners, with XGBoost serving as the meta-learner in the stacking ensemble. The framework is evaluated on an unseen test set using standard classification metrics, while paired t-testing is employed to assess the statistical significance of performance differences. Experimental results identify LOC, CBO, WMC, RFC, LCOM, and MAX_CC as the most influential software metrics. The proposed framework demonstrates statistically significant improvements over the baseline ensemble models, as validated through paired t-testing (t = 4.53, p = 0.0004), indicating the effectiveness of the proposed approach in enhancing software fault prediction performance. SHAP-based explanations provide both global and local interpretations, revealing the contribution of individual software metrics and base-model predictions to fault classification. Overall, the findings indicate that integrating principled feature selection with a boosting-based stacking ensemble can improve software fault prediction performance while providing greater transparency for software quality management.

INTELLIGENT BUG PREDICTION SYSTEM

The intelligent bug prediction system addresses the main problem of identifying the defect-prone software modules in the early stages of the software development life cycle. The conventional testing methodologies are time-consuming and costly and do not provide an effective way to prioritise high-risk modules. This problem is important for improving software reliability, reducing maintenance cost and improving the overall quality of software systems. The current bug prediction techniques mainly rely on traditional machine learning models such as Random Forests, Support Vector Machines (SVMs), and Neural Networks, but they face challenges such as imbalanced data, limited feature sets, low interpretability, and binary predictions that do not provide meaningful guidance for testing prioritisation.In our approach, we propose an intelligent machine learning-based bug prediction framework that uses SMOTE for dataset balancing and feature selection to identify the most relevant software metrics. We also use advanced ensemble learning techniques, such as CatBoost, LightGBM, and the Stacking Ensemble model, to improve prediction accuracy. Methodology: Analysed software metrics from NASA MDP evaluated model performance using Accuracy, Precision, Recall, F1-score, ROC-AUC, and Confusion Matrix; and applied SHAP (SHapley Additive Explanations) to provide transparent and interpretable predictions. A Risk Scoring Mechanism categorises software modules as Stable, High, Medium, or Low risk, and Bug Fix Recommendations help developers more effectively fix predicted defects.The proposed system is expected to produce accurate, explainable, and risk-aware bug predictions. This enables developers to prioritise testing efforts, optimise resource allocation, cut debugging costs, and deliver more dependable, secure, and high-quality software.

Software Failure Prediction and Efficiency Optimization Using AI/ML Techniques

Software reliability remains a major concern in modern software engineering due to the increasing complexity of software systems and the rapid pace of development. Software Failure Prediction (SFP) aims to identify fault-prone modules before deployment, enabling organizations to reduce maintenance costs and improve system quality. Artificial Intelligence (AI) and Machine Learning (ML) techniques provide data-driven approaches for analyzing software metrics, defect repositories, and execution logs to predict failures. This review examines AI/ML-based approaches for software failure prediction and efficiency optimization, with explicit attention to benchmark datasets, dataset quality, preprocessing, class imbalance, feature selection, model families, validation strategies, and evaluation measures. Representative NASA and PROMISE/Jureczko datasets are characterized in terms of software-unit type, metric families, binary defect labels, and imbalance. The review emphasizes Precision, Recall, F1-score, ROC-AUC, and MCC in addition to accuracy and compares traditional ML, ensemble, and deep-learning approaches. It further discusses missing data, concept drift, and cross-project prediction as key factors affecting real-world generalization. The analysis indicates that no single model is universally optimal; robust software failure prediction requires dataset-aware preprocessing, leakage-safe validation, imbalance-aware evaluation, and an explicit trade-off among predictive performance, computational efficiency, and interpretability.

Actionable insights from developer behavior: a practical approach to software defect prediction

Software defect prediction historically relies on code and history metrics, largely ignoring developer-level indicators. Yet, because defects typically stem from human error, human-factors theory offers complementary, theoretically grounded predictors. This paper introduces a framework for deriving prediction metrics from human-factors theory and instantiates it with two metrics, alertness and memory_decay, operationalizing developer cognitive state during code editing. We evaluate these metrics on twenty-one large-scale open-source projects under two complementary protocols: a discovery-oriented (in-sample) evaluation and a time-aware generalization evaluation on a subset of eighteen projects. Under discovery evaluation, models using cognitive metrics dominate state-of-the-art baselines on every project (PR-AUC 0.64 vs. 0.43), and have surfaced over thirty real, previously-unreported defects across nine critical infrastructure projects, including two assigned CVEs and accepted upstream fixes in systems such as NASA Trick. Under time-aware cross-project evaluation, cognitive metrics encode the strongest cross-project predictive signal in the benchmark: alertness ranks first by mean SHAP importance and memory_decay exhibits the lowest rank volatility, a stability independently confirmed by chance-corrected selection-stability analysis; the configuration combining cognitive and traditional metrics significantly outperforms the traditional baseline alone (Holm-corrected \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$p = 0.018$$\end{document}, large effect). Furthermore, cognitive configurations demonstrate a significant, large-effect reverse generalization gap—performing better under cross-project transfer than within-project evaluation—while substituting traditional edit-frequency counts to produce calibration-neutral models. Consequently, our findings validate cognitive theory for explainable, actionable, and interpretable safety-critical defect prediction, laying empirical groundwork to evaluate analogous issues in LLM-generated code through the behavioral study of AI.