A novel approach for software defect prediction using CNN and GRU based on SMOTE Tomek method

Determining source code defects is usually tricky due to software projects' colossal code base. The importance and challenges of defect prediction have made it an active research area in software engineering (Dam et al., 2018). Defects in software are often challenging to detect or identify, and developers spend significant time locating and fixing them. The software life cycle includes many activities to identify source code defects, such as design reviews, code inspections, integration tests, functions testing, unit tests, etc. (Tong et al., 2018). Early detection of a defect in software projects during the development phase helps allocate testing resources reasonably, determine the testing priority of different software modules, and improve the effectiveness of the software development process (Kumar & Singh, 2021). SDP is a process for predicting source code defects using tools or techniques based on historical data. SDP approaches can be divided into with-in-project defect prediction (WPDP), cross-project defect prediction (CPDP) for a similar dataset, and cross-project defect prediction (CPDP) for a heterogeneous dataset (Kalaivani & Beena, 2018; Li et al., 2018).

In this study, we develop our models based on the with-in-project defect prediction (WPDP) approach. In the WPDP approach, a prediction model can be built based on collecting historical data from a software project and predicting defects in the same project. WPDP performs best if there is enough historical data to train the model (Omri et al., 2020). There are two ways in which previous studies have attempted to build accurate SDP models: the first approach is to manually design new features or new sets of features to represent defects more effectively, while the second approach involves applying new and improved ML-based classifiers. Several models have been proposed for SDP based on the second approach (ML-based classifiers). However, there is still a need to develop accurate defect detection models or detectors and robust software metrics to distinguish between defective and non-defective software modules. Latest studies leverage manually designed software metrics such as Halstead features, McCabe features, C.K. features, MOOD features, etc., to build classifiers.

Recently, DL algorithms have been adopted to improve research tasks in software engineering, especially in SDP (Liang et al., 2019; Omri et al., 2020). DL algorithms differ from classical artificial neural networks in one critical aspect: they contain many hidden layers (Ferenc et al., 2020; Koay et al., 2022). DL is a type of ML that allows computational models consisting of multiple processing layers to learn data representations with various levels of abstraction. DL architecture has been widely applied in many fields to solve detection, classification, and prediction problems (Zhu et al., 2020). DL has drawn more and more attention because of its robust feature learning capability and has been successfully used in many domains, such as speech recognition, image classification, etc. The CNN and GRU models are the most popular DL architectures designed to solve the problem of long-term dependencies and gradient vanishing. These models can recognize longer sequences of time series data to provide high predictive performance in SDP (Tong et al., 2018).

Unfortunately, the studies of SDP are facing a big challenge: the class imbalance problem. When there is an uneven distribution of classes in the training data set, this indicates that this data is imbalanced. The class imbalance problem means that the number of non-defective modules (majority class) is much more than that of defective modules (minority class). Imbalanced class classification biases performance towards the majority numbered class in the case of a binary application. Most ML techniques can predict better when each class's instances are roughly equal. This problem severely hinders the efficiency of these models and produces imbalanced false-positive and false-negative results (Lango & Stefanowski, 2018). This study selects imbalanced datasets from the public PROMISE repository for experimental purposes (Chen et al., 2015; Deng et al., 2020a; Phan & Nguyen, 2017);. However, several experiments in the previous studies (Deng et al., 2020a; Khuat & Le 2020; Kumar & Sathyanarayana, 2015; Miholca et al., 2018) were conducted based on these datasets using many ML models; most of the results were very poor because of the class imbalance problem. Very few of these studies are based on CNN and GRU models. However, to our knowledge, there is no experiment using CNN and GRU combined with SMOTE Tomek in the literature.

To bridge these gaps, this study aims to apply data balancing methods to address the problem of class imbalance and investigate the impact of data balancing methods on the performance of ML models in detecting software defects. Firstly, we apply data balancing methods to balance the training set. Secondly, we train and test the proposed models using the balanced training set, and finally, we evaluate the results based on many performance measures. In summary, the goal and main contributions of our study are summarized as follows:

The structure of this paper is organized as follows. Section 2 presents a discussion on related work. Section 3 presents background on software defect prediction, convolutional neural networks, and gated recurrent unit. Section 4 presents the hypothesis and research questions. Section 5 presents the motivation for our proposed work. After that, our research methodology is presented in Section 6. Section 7 presents the experimental results and discussion. Section 8 presents the implication of the findings. Section 9 presents threats to validity, followed by conclusions in the last section (Section 10).

The prediction of defects in software systems is significant, and there is great interest in developing novel high-performance software defect predictors. SDP models aim to improve the quality of software application systems (Khuat & Le, 2020). Many models have been constructed to recognize the defects in software modules using artificial intelligence and statistical methods (Cao, 2020; Dam et al., 2018; Deng et al., 2020a; Qiu et al., 2019; Pan et al., 2019; Tong et al., 2020; Munir et al., 2021). Tong al. (2018) proposed a novel approach for SDP using deep representations combined with the two-stage ensemble to address the class imbalance problem. The experiments were performed on 12 NASA datasets, and results were evaluated based on F-measure, AUC, and MCC. The experimental results showed that (i) deep representations are promising for SDP, (ii) the two-stage ensemble is more effective for addressing the class imbalance problem in SDP compared with classic ensemble learning methods, and (iii) the proposed approach is significantly effective for SDP. HONGLIANG LIANG al. (Liang et al., 2019) proposed Seml, a novel framework that combines word embedding and LSTM for SDP. The model was evaluated based on eight open-source projects. The experimental results showed that the Seml outperforms three state-of-the-art defect prediction approaches on most datasets for both within-project and cross-project defect prediction. Ferenc et al. (2020) proposed a methodology of how to adapt DNNs s for bug prediction. The methodology was applied on a large bug dataset (containing 8780 bugged and 38,838 not bugged Java classes). The results demonstrate that DL with static metrics can indeed boost prediction accuracies. Kun Zhu et al. (2020) proposed a novel just-in-time defect prediction model named DAECNN-JDP based on denoising autoencoder and CNN. The model was evaluated based on six large open-source projects and compared with 11 baseline models. The experimental results showed that the proposed model outperforms these baseline models. Deng et al. (2020a) proposed a novel LSTM method to perform SDP; their method can automatically learn semantic and contextual information from the program's ASTs. The experiment was performed on several open-source projects, showing that the proposed LSTM method is superior to the state-of-the-art methods. Khuat and Le ( 2020) conducted an empirical study to evaluate the importance of sampling techniques in SDP. The experimental results indicated the positive effects of combining sampling techniques with ensemble learning models. This method addressed the class imbalance problem and achieved high prediction accuracy. Miholca et al. (2018) presented a supervised classification approach named (HyGRAR). It is a nonlinear hybrid model that combines gradual relational association rule mining and artificial neural networks to predict software defects. The experiments were conducted using ten open-source datasets. The experimental results showed the excellent performance of the proposed classifier and better performance than most of the previously proposed classifiers. This method achieved high prediction accuracy. Kumar and Satyanarayana (2015) developed a Hybrid Neural Network model with object-oriented and C.K. metrics for software fault prediction. Adaptive Genetic Algorithm has been used for ANN optimization. The proposed model has been tested with PROMISE data sets. The experimental results showed better performance compared to major existing schemes. Hao Xu et al. (Qiu et al. 2019) proposed a novel approach using the transfer CNN model to mine the transferable semantic features for CPDP tasks. The experiments were conducted based on ten benchmark projects with 90 pairs of CPDP tasks. Their results showed that the proposed model is superior to the reference methods. Pan et al. (2019) proposed an improved CNN model for WPDP and compared the experimental results with those of existing CNN studies. An experiment was performed using a 30-repetition holdout validation and a 10 * 10 cross-validation. Their results showed that the CNN model significantly outperformed the state-of-the-art ML models for WPDP. Tong et al. (2020) proposed a novel credibility-based imbalance-boosting method to address the class imbalance problem in software defect proneness prediction. Experiments were performed on datasets obtained from the NASA and PROMISE datasets. The proposed method was compared with several approaches. The experimental results showed that the proposed method is a more promising alternative for addressing the class imbalance problem than previous methods. Munir et al. (2021) proposed a new framework based on GRU and LSTM for SDP. The experiments were evaluated based on 119,989 C/C +  + programs in Code4Bench. The proposed method was compared with several approaches. The experimental results demonstrated that the proposed method performs better regarding a recall, precision, accuracy, and F1 metrics. Li et al. (2017) proposed a framework based on the programs' Abstract Syntax Trees called Defect Prediction via CNN. The model was evaluated based on seven open-source projects in terms of f-measure. The experimental results showed that the model improves the state-of-the-art method by 12% on average. Kukkar et al. (2019) proposed a novel DL model for multiclass severity classification called bug severity classification using a CNN and Random Forest with Boosting based on five open-source projects. Their results prove that the proposed model enhances the performance of bug severity classification over state-of-the-art techniques. Pandey et al. (2020) proposed a new method using deep representation and ensemble learning (BPDET) for software bug prediction; ensemble learning was applied to address the class imbalance problem. An experiment was performed based on 12 data sets from the PROMISE repository. The experimental results showed that the proposed method outperformed existing state-of-the-art techniques. This method addressed the class imbalance problem and achieved high prediction accuracy. Zhao Yang and Hongbing Qian (Yang et al., 2018) proposed an ANNs model, which automated parameter tuning techniques to optimize the defect prediction models. The model was evaluated based on 30 datasets downloaded from the Tera-PROMISE Repository. Their results showed that the proposed model performance improved after tuning parameter settings. The authors suggested that researchers should pay attention to tuning parameter settings by Caret for ANNs instead of using suboptimal default settings if they select ANNs for training models in future defect prediction studies. Zhao et al. (2019) proposed a novel SDP model called Siamese parallel fully-connected networks (SPFCNN), combining Siamese networks' advantages and DL. The authors compared the proposed model with the state-of-the-art SDP models using six datasets from the NASA repository. The experimental results showed that the proposed model contributes significantly higher performance than benchmarked SDP approaches. Farid et al. (2021) proposed a hybrid model using bidirectional long short-term memory and CNN to predict software defects. The proposed model was evaluated using seven open-source Java projects from the PROMISE datasets. Their results showed that the proposed model is accurate for predicting software defects. Fan et al. (2019) presented an SDP framework via an attention-based RNN. The models were evaluated based on an open-source Apache Java project, using F1-measure and AUC. The experimental results demonstrated that the proposed model improves the F1 measure by 14% and AUC by 7% compared with the state-of-the-art methods. Majd et al. (2020) proposed SLDeep using LSTM as a learning model, a technique for statement-level SDP based on more than 100,000 C/C +  + projects. The results showed that the proposed model seems effective at statement-level SDP and can be adopted. Feng al. (2021) investigated the role of SMOTE-based and stable SMOTE-based oversampling techniques in improving SDP. The approach was evaluated based on four common classifiers across 26 datasets from the PROMISE Repository. This method addressed the class imbalance problem and achieved high prediction accuracy. The experimental analysis showed that the performance of stable SMOTE-based oversampling techniques is more stable and better than that of SMOTE-based oversampling techniques.

After reviewing previous studies in SDP, we noticed that most proposed methods ignore the class imbalance problem. According to studies that addressed the class imbalance problem (Feng et al., 2021; Khuat & Le, 2020; Pandey et al., 2020; Tong et al., 2018, 2020), the authors point out that the data balancing methods are essential in improving SDP accuracy. So, the primary point from the recent studies is that ML combined with data balancing methods can improve and increase prediction accuracy. Therefore, this work aims to address the class imbalance problem to enhance the efficiency of the proposed models.

This section briefly introduces software defect prediction, convolutional neural networks, and gated recurrent unit.

In this section, we will discuss the hypothesis and motivation along with research questions and then mention some existing studies addressing the class imbalance problem.

Our hypothesis in this study is if data balancing methods are applied to balance the original data sets, the classification performance of the proposed models will be better in SDP. To investigate our hypothesis, we used a paired t-test to find out whether there was a statistically significant difference between our models on the original and balanced datasets. The formula for the paired t-test is shown in Eq. 7 below. To statistically prove the validity of the impact of data balancing methods on the performance of ML algorithms, the hypothesis is formed as follows:where m is the mean differences, n is the sample size (i.e., number of pairs), and s is the standard deviation.

Based on our hypothesis, this study aims to understand the impact of data balancing methods on the performance of ML algorithms in SDP. In particular, we aim to address the following research questions.

This RQ. Investigates data balancing methods to improve the accuracy of ML models in SDP.

This RQ. It aims to investigate the performance of the proposed approach in SDP compared to the state-of-the-art approaches.

The motivation for the above research questions relates to the importance of applying data balancing methods in SDP studies. According to the latest research on SDP, applying data balancing methods is important in predicting software defects using ML algorithms to ensure that the model is not biased toward the majority class and can accurately predict defective and non-defective modules. Some studies in SDP that applied data balancing methods to address the class imbalance problem revealed that data balancing methods have an important role in improving the accuracy of ML models in SDP. Tong Haonan al. (Tong et al., 2018, 2020) prove in their work that the two-stage ensemble and credibility-based imbalance-boosting are more effective methods for addressing the class imbalance problem in SDP than classic ensemble learning methods. Thanh Tung Khuat and My Hanh Le. (Khuat & Le, 2020) prove in their work that there are positive effects of combining sampling techniques with ensemble learning models in improving the accuracy of SDP. Pandey et al. (2020) prove in their work that combining deep representation with ensemble learning positively enhances the accuracy of software bug prediction. Feng al. (2021) prove in their work that the stable SMOTE-based oversampling techniques are more durable and better than the SMOTE-based oversampling technique.

According to the literature, existing SDP studies suffer from the class imbalance problem. So, several reasons motivate us to apply data balancing methods in predicting software defects using ML algorithms:

In this section, we present our proposed methodology for SDP using novel ML models (CNN and GRU) combined with data sampling methods (SMOTE Tomek method). We have acquired the datasets from the PROMISE repository. We have applied data pre-processing techniques to deal with problems such as noise and unwanted outliers, missing values, feature type conversion, and normalization. We have also used feature selection techniques to choose the features more relevant to the target class. Then, we applied data balancing methods to balance the training stet. The datasets are split into training and testing datasets to train and test the proposed models. Finally, we built and evaluated our models based on many standard performance measures. A series of steps have been taken and described, such as benchmark datasets used, software metrics used, data pre-processing, features selection, dataset balancing, and performance measures used. Figure 3 illustrates the whole workflow of the proposed SDP methodology, where each step is described in the following sections.

In this section, we evaluate the efficiency of our proposed models. The experimental environment was based on Python and used data from the same project for training and testing. The study has considered six open-source datasets for empirical analysis using CNN and GRU. As part of our experimental analysis, we employed the traditional ML (RF) algorithm as a baseline model and compared it with our proposed models.

To answer the research question—RQ1, the performance of the prediction models is reported in Tables 5, 6, 7, 8, 9, 10, 11, 12, and Figs. 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21 are mentioned below.

Table 12 below presents the statistical analysis results (paired t-test) of proposed models on the original and balanced datasets regarding mean, Standard Deviation (STD), min, max, and P value. We notice that the mean values of the CNN model are 0.90 on the original datasets and 0.92 on the balanced datasets, while the mean values of the GRU model are 0.89 on the original datasets and 0.91 on the balanced datasets. The STD values of the CNN model are 0.06 on the original datasets and 0.06 on the balanced datasets, while the STD values of the GRU model are 0.07 on the original datasets and 0.07 on the balanced datasets. The Min values of the CNN model are 0.82 on the original datasets and 0.84 on the balanced datasets, while the Min values of the GRU model are 0.79 on the original datasets and 0.82 on the balanced datasets. The Max values of the CNN model are 0.96 on the original datasets and 0.97 on the balanced datasets, while the Max values of the GRU model are 0.97 on the original datasets and 0.99 on the balanced datasets. The P value of the CNN model is 0.015 based on the original and balanced datasets, while the P value of the GRU model is 0.000 based on the original and balanced datasets. Based on the P value of both models on the original and balanced data sets, we note that the P value is less than 0.05, indicating a difference between the results of the models on the original and balanced data sets.

Figure 5 below shows the Box plots of performance measures for the original and balanced datasets (Accuracy, Precision, Recall, F-measure, MCC, AUC, AUCPR, and MSE). The CNN model averages on the original datasets (Accuracy, Precision, Recall, F-measure, MCC, AUC, AUCPR, and MSE) are 0.90, 0.64, 0.48, 0.52, 0.32, 0.76, 0.57, and 0.081, respectively. The CNN model averages on the balanced data sets (Accuracy, Precision, Recall, F-measure, MCC, AUC, AUCPR, and MSE) are 0.92, 0.90, 0.94, 0.92, 0.84, 0.95, 0.93, and 0.066, respectively. The GRU model averages on the original datasets (Accuracy, Precision, Recall, F-measure, MCC, AUC, AUCPR, and MSE) are 0.89, 0.58, 0.49, 0.51, 0.28, 0.70, 0.57, and 0.090, respectively. The averages of (Accuracy, Precision, Recall, F-measure, MCC, AUC, AUCPR, and MSE) of the GRU model on the balanced data sets are 0.91, 0.92, 0.91, 0.91, 0.82, 0.94, 0.94, and 0.082, respectively.

Figures 6, 7, 8, 9, 10, 11, 12, 13 below show the training and validation accuracy and training and validation loss of the models on the original and balanced datasets. Figure 6 shows the accuracy values of the CNN model on the original data sets. The accuracy values are 0.83 on the ant data set, 0.82 on the camel data set, 0.90 on the ivy data set, 0.96 on the jedit data set, 0.95 on the log4j data set, and 0.94 on the xerces data set. Figure 7 shows the accuracy values of the CNN model on the balanced data sets. The accuracy values are 0.85 on the ant data set, 0.84 on the camel data set, 0.95 on the ivy data set, 0.97 on the jedit data set, 0.97 on the log4j data set, and 0.95 on the xerces data set. Figure 8 shows the accuracy values of the GRU model on the original data sets. The accuracy values are 0.81 on the ant data set, 0.79 on the camel data set, 0.92 on the ivy data set, 0.97 on the jedit data set, 0.95 on the log4j data set, and 0.91 on the xerces data set. Figure 9 shows the accuracy values of the GRU model on the balanced datasets. The accuracy values are 0.83 on the ant data set, 0.82 on the camel data set, 0.95 on the ivy data set, 0.99 on the jedit data set, 0.96 on the log4j data set, and 0.93 on the xerces data set. Figure 10 shows the loss values of the CNN model on the original data sets. The loss values are 0.131 on the ant data set, 0.136 on the camel data set, 0.086 on the ivy data set, 0.037 on the jedit data set, 0.048 on the log4j data set, and 0.049 on the xerces data set. Figure 11 shows the loss values of the CNN model on the balanced data sets. The loss values are 0.117 on the ant data set, 0.132 on the camel data set, 0.051 on the ivy data set, 0.027 on the jedit data set, 0.028 on the log4j data set, and 0.043 on the xerces data set. Figure 12 shows the loss values of the GRU model on the original data sets. The loss values are 0.152 on the ant data set, 0.146 on the camel data set, 0.076 on the ivy data set, 0.028 on the jedit data set, 0.048 on the log4j data set, and 0.090 on the xerces data set. Figure 13 shows the loss values of the GRU model on the balanced data sets. The loss values are 0.130 on the ant data set, 0.144 on the camel data set, 0.055 on the ivy data set, 0.026 on the jedit data set, 0.073 on the log4j data set, and 0.064 on the xerces data set.

As shown in the figures, the accuracy of training and validation increases and the loss decreases with increasing epochs. Regarding the high accuracy and low loss obtained by the proposed models, we note that the models are well-trained and validated.

Figures 14, 15, 16, 17 below show the ROC curves of the models on the original and balanced datasets. Figure 14 shows the AUC values of the CNN model on the original data sets. The best AUC obtained is 95% on the xerces data set, while the worst AUC is 46% on the log4j data set. Figure 15 shows the AUC values of the CNN model on the balanced data sets. The best AUC obtained is 99% on the log4j and xerces data sets, while the worst AUC is 90% on the camel data set. Figure 16 shows the AUC values of the GRU model on the original data sets. The best AUC obtained is 93% on the jedit data set, while the worst AUC is 29% on the log4j data set. Figure 17 shows the AUC values of the GRU model on the balanced data sets. The best AUC obtained is 100% on the jedit data set, while the worst AUC is 87% on the camel data set.

Figures 18, 19, 20, 21 below show the AUCPR of the models on the original and balanced datasets. Figure 18 shows the AUCPR values of the CNN model on the original data sets. The best AUCPR obtained is 98% on the xerces data set, while the worst AUCPR is 7% on the jedit data set. Figure 19 shows the AUCPR values of the CNN model on the balanced data sets. The best AUCPR obtained is 99% on the log4j and xerces data sets, while the worst AUCPR is 88% on the jedit data set. Figure 20 shows the AUCPR values of the GRU model on the original data sets. The best AUCPR obtained is 93% on the log4j data set, while the worst AUCPR is 24% on the jedit data set. Figure 21 shows the AUCPR values of the GRU model on the balanced data sets. The best AUCPR obtained is 100% on the jedit and jedit data sets, while the worst AUCPR is 84% on the camel data set.

After comparing the results obtained by the proposed models on the original datasets with results obtained by the proposed models on the balanced datasets, as shown in the tables and figures, we note that the models got good scores on the balanced datasets. The results improved further due to balancing, which indicated that the proposed models performed well and data balancing methods play an important role in improving the models' accuracy.

To answer the research question—RQ2, we compared the results produced using our models with those obtained using the baseline model (RF) based on six performance measures: accuracy precision, recall, f-Measure, MCC, and AUC. Table 13 below compares our models with the baseline model (RF). According to Table 13, our models outperform the baseline model in some datasets. We also compared the results produced using our models with those obtained in previous studies based on six performance measures: accuracy precision, recall, f-Measure, MCC, and AUC. Table 14 below compares the performance measures obtained by our models and the performance values in previous studies. The best values are indicated with bold text and "- "to indicate the approaches that did not provide results in a particular data set. According to Table 14, some of the results in the previous studies are better than ours. Still, in most cases, our models outperform the state-of-the-art approaches and provide better predictive performance.

The findings have implications for researchers. Researchers are interested in quantitatively understanding the effectiveness and efficiency of applying data balancing methods with ML techniques in SDP. Furthermore, the formers are concerned about the qualitative perspective of the results. So, in the earlier sections, we reported the implications of effectiveness, efficiency, comparison, and relation with previous work (experimental results and discussion).

This section discusses the threats to our study's validity and experiment limitations and how we mitigate them. It is vital to assess the threats to validity, such as construct, internal, external, and experiment limitations, particularly constraints on the search process and deviations from the standard practice.

Construct validity concerns the study's design and its possibility to reflect the actual goal of the research. To avoid threats in study design, we have applied a procedure of systematic literature review. To ensure that researched area is relevant to the study goal, we cross-checked the research questions and adjusted them several times. Besides, the metrics considered may be a threat to our study. We only adopt static code metrics to predict defects. Thus, we cannot claim that we could generalize our conclusion to other metrics. However, many previous studies also widely adopted static code metrics (Chen et al., 2015; Feng et al., 2021). Another threat is the construction of ML models. We considered several aspects that could have influenced the study, i.e., data pre-processing, which features to think about, how to train the models, etc. However, the procedures followed in this respect are precise enough to ensure the study's validity.

Threats to internal validity are related to the correctness of the experiment's outcome or the study's process. The main threat to internal validity is datasets. The reference datasets are imbalanced datasets that show a lack in the actual distribution of the percentage of defects and non-defective classes. We manage this threat by modifying the original datasets to increase the realism of the data in terms of the defect's actual presence in the software system. The distribution of the dataset is modified by applying two data sampling techniques. Another threat is that most of our datasets have a small number of defects. These small number of defects make it challenging to generate statistically significant results; we tried to minimize that threat by applying standard performance measures for SDP; however, we acknowledge that several statistical tests (Arcuri & Briand, 2014) can be used to verify the statistical significance of our conclusions. Therefore, we plan to conduct more statistical tests in our future work.

External validity relates to the study's generalizability to a broader range of applications. We tried to select and gather different types of datasets from various projects of the PROMISE repository to test our experiment. Our criteria in project selection were based on the ratio of defects. So, we chose projects with a high and low percentage of defects (projects with imbalanced classes) to help us apply data balancing methods. We built our model to adapt the combination of ML with balancing techniques in SDP. We selected six open-source Java projects of the PROMISE dataset as our evaluation datasets. However, we cannot declare that our results can be generalized. Future replication is necessary to confirm the generalizability of our findings in this study.

The limitations of the experiments are summarized as follows. First, the datasets used in our experiments are limited to only six open-source Java projects. Second, our findings may not be sufficient for generalization.

Various ML and DL techniques have recently been used to build SDP models. Software defects significantly impact the software development life cycle, and defect prevention plays a vital role in software quality assurance and the effective help of software maintenance. SDP is a process of generating models or tools to predict software defects based on historical data. Early defect prediction helps prioritize and optimize effort and costs for inspection and testing. Historical software metrics that indicate defective data are primary inputs to the models. To improve the existing state-of-the-art approaches to predict software defects, we proposed a novel approach based on CNN and GRU combined with SMOTE Tomek to predict defects in the source code. The data sampling method (SMOTE Tomek) was used to address the class imbalance problem. To evaluate the effectiveness of the proposed models, we performed a series of experiments on six public software defect datasets. The results were compared with random forest (RF) as a baseline model. We found that the proposed models on the balanced datasets with an average precision of 90% for the CNN model and 92% for the GRU model compared with the RF model (62%). Our results showed that the proposed models on the balanced datasets improve the average precision by 28% and 30%, respectively, compared to the RF model, which proves that the proposed models outperform a baseline model. The average Accuracy, Precision, Recall, F-Measure, and MCC of the proposed models on the original datasets was 90%, 64%, 48%, 52%, and 32%, respectively, for the CNN model and 89%, 58%, 49%, 51%, and 28%, respectively, for the GRU model. In comparison, the average Accuracy, Precision, Recall, F-Measure, and MCC of the proposed models on the balanced datasets was 92%, 90%, 94%, 92%, and 84%, respectively, for the CNN model and 91%, 92%, 91%, 91%, and 82%, respectively for the GRU model. The experimental results demonstrate that the proposed models perform better and that there are positive effects of combining CNN and GRU models with SMOTE Tomek method on the performance of SDP regarding datasets with imbalanced class distributions, and our approach is a more promising alternative for addressing the problem of class imbalance in SDP as compared with previous methods. The robustness and accuracy of our proposed approach will be evaluated on various datasets in our future work.