Preferred software reliability growth model method based on weighted grey correlation analysis

Abstract

The present invention belongs to the technical field of software reliability growth model, and relates to an optimal software reliability growth model method based on a weighted grey relational analysis method. In the present invention, an optimal software reliability growth model method based on a weighted grey relational analysis method is proposed. These models include closed-source and open-source software reliability growth models, as well as perfect and imperfect debugging software reliability growth models. In order to effectively verify the effectiveness of the proposed method, 12 different software reliability growth models, 11 model evaluation criteria and two consecutive versions of open-source software fault data sets are used. The research results show that the method can select the optimal software reliability growth model in the current software development and testing environment. In summary, the present research has important practical significance for actual software development and testing, and makes an important contribution to helping developers or testers select the optimal software reliability growth model for software reliability evaluation.

Description

Technical Field

[0001] This invention belongs to the technical field of software reliability growth models, specifically relating to a method for optimizing software reliability growth models based on weighted grey relational analysis. Background Technology

[0002] To facilitate people's daily needs, various software programs have been developed and used. Modern society is inseparable from the development of computers and artificial intelligence. When software malfunctions in a computer, it can cause enormous losses and even threaten human lives. Under the premise of meeting the requirements for software reliability, various software reliability growth models are constantly being developed. In modern society, the functions implemented by software are becoming increasingly complex, and the size of the code is also growing larger, resulting in no single software reliability growth model being able to accurately predict the number of remaining faults in software under all software testing environments, or effectively estimate the degree of software reliability in all software development and testing environments.

[0003] Given the current development and testing environment, choosing the most suitable software reliability growth model is crucial. Researchers have proposed different methods to optimize the selection of software reliability models. For example, Ullah et al. first compared R... 2 The optimal software reliability growth model is selected by choosing the model with the best fit performance, and then the number of remaining software faults between the number of faults predicted and the number of faults actually detected is chosen, which is less than or equal to a threshold. Sharma et al. used Euclidean Composite Distance (ECD) to select the optimal software reliability growth model. This method compares the performance metric of each model with the optimal performance metric and calculates the sum of the Euclidean Composite Distances between each model and the optimal alternative. Yaghoobi proposed using Shannon entropy as the optimal selection criterion for SRGM, and he also proposed using variance as a criterion to optimize the selection of the software reliability growth model. By comparing information entropy, variance, and ECD, consistency among them was found. Garg combined entropy and distance methods to select the optimal software reliability growth model. Comparing this method with AHP and TOPSIS, correlations were found among their ranking methods.

[0004] Generally, statistical expertise is the preferred method for selecting the most suitable software reliability growth model. Statistical techniques are reliable in identifying the optimal software reliability growth model when the patterns or probability distributions of the fault dataset in a sample are known. However, in real-world software testing, fault detection is unpredictable, and the number of detected faults is finite, which presents significant difficulties and challenges in attempting to discover patterns and probability distributions in fault detection. Therefore, the selection of the optimal software reliability growth model using statistical methods is influenced by the actual number of detected faults and the sample size.

[0005] Due to the complexity and uncertainty of software development and testing, developed software reliability growth models can only effectively predict the number of remaining faults in software and assess software reliability under certain environments and conditions. For example, in a perfect debug (PD) environment, the Delayed S-shaped (DSS) model assumes that the fault detection curve follows an S-shape over time; the Inflection Point S-shaped (ISS) model assumes that there is a learning phenomenon in the fault detection process, and the cumulative number of detected faults follows an S-shaped curve over time; the Goel-Okumoto (GO) model assumes that the fault detection rate is constant; the Generalized Goel (GGO) model assumes that fault detection follows a Weibull distribution; the Generalized Inflection Point S-shaped (GISS) model assumes that the fault detection rate follows a generalized inflection point sigmoid distribution; and the Li model based on open-source software assumes that fault detection increases first and then decreases with testing time.

[0006] Furthermore, in the imperfect debugging (ID) environment, Yamada Imperfect Debugging Model 1 (YID1) assumes that fault introduction follows an exponential distribution. Yamada Imperfect Debugging Model 2 (YID2) assumes that fault introduction exhibits a linear change over time. The PZ model assumes that fault introduction changes non-linearly over time. The Zhang Teng Pham (ZTP) model assumes that the fault introduction rate is constant and that the S-shaped fault detection rate function changes non-decreasingly over time. The PNZ model assumes that not only does the fault detection rate exhibit an S-shaped curve over time, but fault introduction also changes linearly over time. The Singhal model, based on open-source software, assumes that during software debugging, the fault introduction rate exhibits irregular fluctuations over time, and that fault introduction follows an exponential distribution.

[0007] In software testing, the collected fault data is a small sample, making it difficult to determine the probability distribution of the fault data. The fault detection process and environment are complex, uncertain, and dynamic. It is difficult to apply software reliability growth models to all software testing environments. In actual fault detection, the amount of detected fault data fluctuates frequently, even exhibiting abrupt changes. It is difficult to find changes in the probability distribution of fault detection. Furthermore, various evaluation criteria for models may differ in their assessment methods. Therefore, in the current software testing environment, selecting the optimal software reliability growth model requires comprehensive consideration of various model performance evaluation criteria. Summary of the Invention

[0008] This invention addresses the problems existing in the background technology by providing a method for optimizing software reliability growth models based on weighted grey relational analysis.

[0009] The present invention adopts the following technical solution:

[0010] A method for optimizing software reliability growth models based on weighted grey relational analysis includes the following steps:

[0011] Step 1, weights based on Shannon entropy;

[0012] Using information from multiple evaluation criteria of the software reliability growth model, the entropy of each evaluation criterion is calculated, and then the weight values ​​are calculated, given a matrix Z with m rows and n columns as follows:

[0013]

[0014] In matrix Z, each row represents a different model, and each column represents the evaluation criteria used to evaluate the model. Matrix Z contains m software reliability growth models and n evaluation criteria for the models; ij Let i represent the evaluation criteria for the i-th and j-th models, where i = 1, 2, ..., m and j = 1, 2, ..., n; the specific steps for calculating the weights based on Shannon entropy are as follows:

[0015] Step 1.1, standardization of matrix Z;

[0016] If the value of the model evaluation metric is smaller, the model performance is better. The standardization of matrix Z can be expressed as follows:

[0017]

[0018] Conversely, the larger the criterion value of the model evaluation, the better its performance. The normalization of matrix Z can be expressed as follows:

[0019]

[0020] In the formula, q1 and q2 are constants, q1 = 0.999999, q2 = 0.000001, and q1 + q2 = 1; S ij Let represent the i-th row and j-th column of matrix Z after standardization, where i = 1, 2, ..., m and j = 1, 2, ..., n;

[0021] Step 1.2, calculate the entropy value of each model evaluation criterion in matrix Z, using the following formula:

[0022]

[0023] Where ln represents the logarithm to the base e;

[0024] Step 1.3, the weight of each model evaluation criterion in matrix Z, is calculated using the following formula:

[0025]

[0026] Among them, wj This represents the weight of the model evaluation criteria in the j-th column of matrix Z;

[0027] Step 2, weighted grey relational analysis method;

[0028] The correlation between different sequence models is determined based on the similarity of the geometric shapes of different sequence curves. The specific steps of the weighted grey relational analysis method for selecting the software reliability growth model are as follows:

[0029] Step 2.1, Equation (1) is standardized using Equation (2) or Equation (3) as follows:

[0030]

[0031] Among them, s mn After standardization, matrix S ij The m-th row and the n-th column;

[0032] Step 2.2: Use the minimum value in each column of the matrix as the optimal evaluation criterion value, as shown below:

[0033]

[0034] in, Representation matrix S ij The minimum value in each column is used as the optimal evaluation standard value, and the superscript 1, 2, ..., n indicates which column it is;

[0035] Step 2.3, calculate s in equation (7). ij and The distance between each column is calculated using the formula shown below:

[0036]

[0037] in, Representation matrix S ij The optimal evaluation criterion value in the j-th column. Represents the matrix ΔΦ ij The minimum value in each column, Represents the matrix ΔΦ ij Maximum value in each column;

[0038] Step 2.4, the grey relational coefficient is calculated as follows:

[0039]

[0040] Where κ represents the discrimination coefficient, and its value is 0.5;

[0041] Step 2.5, the weighted grey relational degree based on Shannon entropy is shown below:

[0042]

[0043] Where, ρ i This represents the grey relational degree; the higher the value, the better the model's performance.

[0044] Compared with the prior art, the present invention has the following advantages:

[0045] 1. When the faults detected during software testing are of small sample size, limited data, and poor information, the proposed method can select the software reliability growth model that is most suitable for the current software testing environment.

[0046] 2. When the distribution and pattern of fault data detected in the software are unclear, a method for optimizing the selection of the software reliability growth model is proposed. This method can explore the actual pattern of fault data by using the data sequence operator.

[0047] 3. The proposed method for optimizing the selection of software reliability growth models can make full use of various evaluation information of model performance, calculate weight priorities through information entropy, and mine the potential information values ​​of the model, making an important contribution to the selection of the optimal software reliability growth model. Attached Figure Description

[0048] Figure 1 This is a schematic diagram illustrating the comparison of software reliability growth models using the fault dataset DS1-1, as presented in this invention.

[0049] Figure 2 This is a schematic diagram illustrating the comparison of software reliability growth models using the fault dataset DS1-2, as presented in this invention.

[0050] Figure 3 This is a schematic diagram illustrating the comparison of software reliability growth models using the fault dataset DS1-3.

[0051] Figure 4 This is a schematic diagram illustrating the comparison of software reliability growth models using the fault dataset DS2-1.

[0052] Figure 5 This is a schematic diagram illustrating the comparison of software reliability growth models using the fault dataset DS2-2, as presented in this invention.

[0053] Figure 6 This is a schematic diagram illustrating the comparison of software reliability growth models using the fault dataset DS2-3.

[0054] Figure 7 This is a schematic diagram showing the ranking comparison results of twelve software reliability growth models using the fault dataset DS1 in this invention;

[0055] Figure 8This is a schematic diagram showing the ranking comparison results of twelve software reliability growth models using the DS2 fault dataset in this invention. Detailed Implementation

[0056] Example 1

[0057] To evaluate the performance of the software reliability growth model, various evaluation metrics were used for fitting and prediction performance assessment, such as MSE, TS, and R. 2 In all software reliability growth model evaluation criteria, no single model outperforms all others in all evaluation metrics. That is, when comparing multiple software reliability growth models, each model may have at least one better evaluation metric value than the others. This makes it difficult to intuitively determine which software reliability growth model is optimal and best suited to current software development and testing conditions when using multiple evaluation criteria to assess model performance. For multiple evaluation criteria, each software reliability growth model can have at least one optimal evaluation metric value. To address this, this paper proposes using grey relational analysis to comprehensively study the various evaluation metrics of the models. Shannon entropy is used to calculate the intrinsic information of the evaluation metric values ​​of multiple models and is used as the weights in the grey relational analysis to select the optimal software reliability growth model.

[0058] A preferred software reliability growth model based on weighted grey relational analysis includes the following steps:

[0059] (1) Weights based on Shannon entropy;

[0060] Using information from multiple evaluation criteria of the software reliability growth model, the entropy of each evaluation criterion is calculated, and then the weight values ​​are calculated, given a matrix Z with m rows and n columns as follows:

[0061]

[0062] In matrix Z, each row represents a different model, and each column represents the evaluation criteria used to evaluate the model. Matrix Z contains m software reliability growth models and n evaluation criteria for the models; ij Let i represent the evaluation criteria for the i-th and j-th models, where i = 1, 2, ..., m and j = 1, 2, ..., n; the specific steps for calculating the weights based on Shannon entropy are as follows:

[0063] a. Standardization of matrix Z;

[0064] If the value of the model evaluation metric is smaller, the model performance is better. The standardization of matrix Z can be expressed as follows:

[0065]

[0066] Conversely, the larger the criterion value of the model evaluation, the better its performance. The normalization of matrix Z can be expressed as follows:

[0067]

[0068] In the formula, q1 and q2 are constants, where q1 = 0.999999, q2 = 0.000001, and q1 + q2 = 1; S ij Let represent the i-th row and j-th column of matrix Z after standardization, where i = 1, 2, ..., m and j = 1, 2, ..., n;

[0069] b. Calculate the entropy value of each model evaluation criterion in matrix Z, using the following formula:

[0070]

[0071] Where ln represents the logarithm to the base e;

[0072] c. The weight of each model evaluation criterion in matrix Z, calculated using the following formula:

[0073]

[0074] Among them, w j This represents the weight of the model evaluation criteria in the j-th column of matrix Z;

[0075] The algorithm for calculating weights based on Shannon entropy is as follows:

[0076]

[0077]

[0078] (2) Weighted grey relational analysis method;

[0079] Grey relational analysis, derived from Deng's grey theory, determines the correlation between different sequence models based on the similarity of the geometric shapes of different sequence curves. The specific steps of grey relational analysis for selecting the optimal software reliability growth model are as follows:

[0080] S1, Equation (1) is standardized using Equation (2) or Equation (3) as follows:

[0081]

[0082] Among them, s mn After standardization, matrix S ij The mth row and the nth column.

[0083] S2. The minimum value in each column of the matrix is ​​used as the optimal evaluation criterion value, as shown below:

[0084]

[0085] in, Representation matrix S ij The minimum value in each column is used as the optimal evaluation standard value, and the superscript 1, 2, ..., n indicates which column it is;

[0086] S3. Calculate s in equation (7). ij and The distance between each column is calculated using the formula shown below:

[0087]

[0088] in, Representation matrix S ij The optimal evaluation criterion value in the j-th column. Represents the matrix ΔΦ ij The minimum value in each column, Represents the matrix ΔΦ ij Maximum value in each column;

[0089] S4. The grey relational coefficient is calculated as follows:

[0090]

[0091] Where κ represents the discrimination coefficient, and its value is 0.5;

[0092] S5. The weighted grey relational degree based on Shannon entropy is shown below:

[0093]

[0094] Where, ρ i This represents the grey relational degree; the higher the value, the better the model's performance.

[0095] The algorithm for weighted grey relational analysis is as follows:

[0096]

[0097]

[0098] Example 2

[0099] experiment

[0100] (1) Fault Dataset

[0101] To verify the effectiveness of the proposed optimization selection method, we used two open-source software projects: Apache Airavata (https: / / issues.apache.org / jira / issues), a fault tracking system, and Mozilla Firefox (https: / / bugzilla.mozilla.org), a vulnerability tracking system. We obtained six fault datasets from the two open-source software projects, each consisting of three consecutive software releases.

[0102] The first fault dataset (DS1) includes AIRAVATA0.12JIRA (DS1-1), AIRAVATA0.13JIRA (DS1-2), and AIRAVATA0.14JIRA (DS1-3). From November 2012 to June 2014, 100 faults were collected in DS1-1. From September 2012 to July 2014, 48 faults were collected in DS1-2. From June 2012 to December 2014, DS1-3 collected a total of 50 faults.

[0103] The second fault dataset (DS2) comes from the literature and includes Firefox 3.0 (DS2-1), Firefox 3.5 (DS2-2), and Firefox 3.6 (DS2-3). In DS2-1, a total of 65 faults were detected after 53 weeks. In DS2-2, 51 faults were found within 28 weeks. In DS2-3, a total of 33 faults were detected after 50 weeks.

[0104] (2) Software reliability growth model

[0105] To verify the effectiveness of the proposed optimization selection method, we used two open-source software projects: Apache Airavata (https: / / issues.apache.org / jira / issues), a fault tracking system, and Mozilla Firefox (https: / / bugzilla.mozilla.org), a vulnerability tracking system. We obtained six fault datasets from the two open-source software projects, each consisting of three consecutive software releases.

[0106] We used 12 different software reliability growth models to validate the effectiveness of the proposed method, including fully debugged and partially debugged software reliability growth models. As shown in Table 1, these models were developed in traditional closed-source software (CSS) or open-source software (OSS) environments. Specifically, there are six fully debugged software reliability growth models and six partially debugged software reliability growth models; ten closed-source software reliability models and two open-source software reliability models. These software reliability models were established in different software testing environments and have different characteristics. The 12 different software reliability growth models can fully validate the effectiveness and credibility of the proposed optimization selection method under various software testing environments.

[0107] Table 1. Software Reliability Growth Model

[0108]

[0109] (3) Model Evaluation Criteria

[0110] We used 11 model evaluation metrics to assess model performance, which evaluate model performance from various aspects. These metrics include KD, mean squared error (MSE), mean absolute error (MAE), mean prediction error (MEOP), estimation accuracy (AE), prediction ratio risk (PRR), variance, root mean square prediction error (RMSPE), and R². 2 The sum of squared errors (SSE) and the Theil statistic (TS). Among them, R... 2 The larger the value of the evaluation criterion, the better the model's fit. The smaller the values ​​of the remaining model evaluation criterions, the better the model's performance. Table 2 lists the evaluation criteria for all models. In actual model performance comparisons, very few models outperform others in all evaluation criteria. This makes it difficult to intuitively select the optimal model based solely on the evaluation criteria. Considering this issue, this paper proposes using a weighted grey relational analysis method to comprehensively examine the evaluation criteria of the SRGM software reliability growth model in order to select the optimal software reliability growth model.

[0111] Table 2.11 Evaluation Criteria for Models

[0112]

[0113]

[0114] (4) Model parameter estimation methods

[0115] Different model parameter estimation methods produce slightly different estimated parameter values. Commonly used parameter estimation methods are maximum likelihood estimation (MLE) and least squares estimation (LSE). MLE performs better on large sample data, but there are cases where parameter values ​​may not exist when using MLE to estimate them. Considering that model parameter values ​​may not exist when using MLE to estimate them, we use LSE to estimate model parameter values ​​to fully verify the effectiveness of the proposed optimization selection method. Typically, software fault datasets are small samples, and there is no significant difference in the effectiveness of using maximum likelihood estimation and least squares estimation to estimate model parameter values. Table 3 lists the details of model parameter values ​​estimated using DS1 and DS2, respectively.

[0116] Table 3. Model parameter values ​​estimated using DS1 and DS2 respectively.

[0117]

[0118]

[0119] (5) Experimental results and discussion on the optimal selection of software reliability growth model based on fault dataset (DS1)

[0120] As can be clearly seen from Table 4, besides KD, AE, and PRR, the ISS model's MSE, MAE, MEOP, Variance, RMSPE, and R are also significantly different. 2 SSE and TS outperform other models. Except for the ISS model, the Li model performs better in MSE, MAE, MEOP, Variance, RMSPE, and R... 2 In terms of SSE and TS, the ZTP model outperforms other models. Except for AE and PRR, the ZTP model also excels in KD, MSE, MAE, MEOP, Variance, RM, SPE, and R. 2 Both SSE and TS performed worse than other models. From... Figure 1 In the data, we can clearly see that among all the models, the ISS model is the best, followed by the Li model, and the ZTP model is the worst.

[0121] Table 4. Evaluation Criterion Values ​​for Twelve Software Reliability Growth Models Using DS1-1

[0122]

[0123]

[0124] Table 5 shows that, except for AE and PRR, the MSE, MAE, MEOP, Variance, RMSPE, and R of the ISS model, Singhal model, and Li model are also similar. 2The SSE and TS models are very close to each other, and their performance is significantly better than other models. Due to the higher AE and PRR values ​​in the Li model, its overall performance is inferior to the ISS and Singhal models. The Singhal model performs significantly worse than the ISS model. Figure 2 This shows the development trends of the ISS model and the Singhal model.

[0125] Table 5. Evaluation Criterion Values ​​for Twelve Software Reliability Growth Models Using DS1-2

[0126] GO 0.555 2630.7 43.68 43.395 113.24 79.303 55.345 56.723 0.5547 399870 53.98 DSS 0.3422 1127.6 26.697 26.523 1079.4 15607 37.617 38.924 0.8091 171390 35.34 ISS 0.2585 142.5 8.7518 8.6942 0.4777 18720 11.823 11.824 0.976 21518 12.522 GGO 0.7052 4041.6 55.268 54.905 3.7621 117.94 65.651 66.521 0.3204 610290 66.687 GISS 0.4851 2209.9 41.523 41.248 1.5642 73.624 54.797 57.309 0.6309 331480 49.147 YID1 0.5738 2778.7 45.113 44.816 0.5624 81.737 56.599 57.983 0.5328 419580 55.294 YID2 0.4316 1769.6 35.604 35.37 2.9513 62.548 47.247 48.958 0.7025 267210 44.127 PNZ 0.2596 247.33 11.045 10.972 0.2114 2803.3 15.886 16.005 0.9587 37100 16.442 PZ 0.2194 454.82 15.451 15.348 0.3538 500.32 22.266 22.676 0.9245 67768 22.222 ZTP 0.666 4320.8 59.081 58.685 0.3393 122.54 67.702 68.748 0.2879 639480 68.263 Li model 0.1852 120.82 8.6107 8.5536 9.0812 213540 11.377 11.546 0.9798 18123 11.492 Singhal model 0.2337 204.38 10.325 10.256 0.3962 5776.7 14.164 14.213 0.9663 30248 14.847

[0127] Table 6 clearly shows that, apart from AE and PRR, the GGO model's KD, MSE, MAE, MEOP, Variance, RMSPE, and R are all significantly different. 2 SSE and TS perform worse than other models. The Li model has the best performance among all models. Except for the ISS model, the Singhal model performs better in KD, MSE, MAE, MEOP, Variance, RMSPE, and R... 2 It outperformed other models in SSE and TS aspects. Figure 3 It can be seen that the ISS model is the best, followed by the Singhal model, and the GGO model is the worst.

[0128] Table 6. Evaluation Criterion Values ​​for Twelve Software Reliability Growth Models Using DS1-3

[0129]

[0130]

[0131] (6) Experimental results and discussion on the optimal selection of software reliability growth model based on fault dataset (DS2)

[0132] Table 7 shows that, except for AE and PRR, the PNZ model has KD, MSE, MAE, MEOP, Variance, RMSPE, and R... 2 SSE and TS are all superior to other models. Next is the YID2 model; except for KD and AE, the PNZ model outperforms other models in MSE, MAE, MEOP, Variance, RMSPE, and R. 2 SSE and TS outperformed other models. The PZ model was the worst performer among all models. These results can be found from... Figure 4 I saw it in the middle.

[0133] Table 7. Evaluation Criterion Values ​​for Twelve Software Reliability Growth Models Using DS2-1

[0134] GO 0.16 16.419 3.6809 3.6087 0.0824 2.5534 4.1008 4.1416 0.9123 820.96 8.2292 DSS 0.2603 41.464 5.7261 5.6138 0.1575 82.94 6.5571 6.6346 0.7784 2073.2 13.077 ISS 0.4315 78.558 8.0696 7.9082 0.2247 45.099 8.6392 8.6507 0.5886 3849.4 17.819 GGO 0.0811 3.027 1.4886 1.4589 2.9635 0.2751 1.6895 1.6897 0.9841 148.32 3.4979 GISS 0.0772 3.1279 1.5748 1.5426 1.3822 0.2572 1.6993 1.6993 0.984 150.14 3.5192 YID1 0.0465 1.1265 0.8736 0.8562 0.4517 0.1029 1.0335 1.0345 0.9941 55.198 2.1338 YID2 0.0448 0.9675 0.7936 0.7777 0.504 0.0886 0.955 0.9551 0.9949 47.407 1.9775 PNZ 0.0372 0.9277 0.7736 0.7578 0.5202 0.1261 0.9256 0.9257 0.9952 44.531 1.9166 PZ 0.3858 116.77 9.0329 8.8447 0.3291 15.152 14.894 16.12 0.4135 5488.1 21.277 ZTP 0.2316 14.38 2.6557 2.5992 0.5385 0.915 3.8168 3.8951 0.9293 661.47 7.3867 Li model 0.1468 13.105 3.3647 3.296 0.1201 1.4994 3.5339 3.552 0.9328 629.04 7.2034 Singhal model 0.0418 1.0422 0.8729 0.8543 0.5583 0.1462 0.9859 0.9942 0.9949 47.941 1.9886

[0135] As can be seen from Table 8, except for the ISS and ZTP models, the 11 criteria of the other models are very similar. Figure 5 As can be seen, among all models, the YID1 model is the best, followed by the YID2 model, and the ISS model is the worst. Furthermore, Table 8 shows that no single model has better evaluation criteria values ​​than the others. Even the worst model has better evaluation criteria values ​​than the others. Therefore, a comprehensive study of the evaluation criteria for the models will be more meaningful.

[0136] Table 8. Evaluation Criterion Values ​​for Twelve Software Reliability Growth Models Using DS2-2

[0137] GO 0.0749 2.0423 1.202 1.1557 0.1082 0.6158 1.3794 1.3808 0.9901 51.057 3.6921 DSS 0.1501 7.498 2.4428 2.3488 0.0664 2.1557 2.7584 2.7969 0.9636 187.45 7.0744 ISS 0.3987 46.66 6.1164 5.8718 0.1564 98.946 6.4925 6.5092 0.7828 1119.8 17.291 GGO 0.0737 2.1256 1.2503 1.2003 0.1158 0.621 1.3799 1.3816 0.9901 51.015 3.6906 GISS 0.0847 2.3454 1.3893 1.3314 0.0905 0.6377 1.4138 1.4139 0.9895 53.943 3.795 YID1 0.0664 2.0098 1.2166 1.168 0.1139 0.6317 1.3482 1.3519 0.9906 48.234 3.5886 YID2 0.0664 2.0162 1.221 1.1722 0.1282 0.6312 1.3496 1.3531 0.9906 48.388 3.5943 PNZ 0.0685 1.8907 1.1455 1.0978 0.41 0.5761 1.2723 1.2733 0.9916 43.485 3.4073 PZ 0.0654 2.1287 1.2943 1.238 0.4471 0.6096 1.3185 1.319 0.9909 46.833 3.5361 ZTP 0.2338 37.446 5.8527 5.5867 0.9608 1.8231 7.0448 7.498 0.8475 786.37 14.49 Li model 0.0702 2.1637 1.2962 1.2422 1.258 0.6258 1.366 1.3687 0.9903 49.765 3.6451 Singhal model 0.064 2.3049 1.3886 1.3255 0.2798 0.6196 1.3394 1.3396 0.9906 48.404 3.5949

[0138] Similarly, Table 9 shows that, except for AE and PRR, the PNZ model's KD, MSE, MAE, MEOP, Variance, RMSPE, and R... 2 The ZTP model outperformed other models in SSE and TS, followed by the YID1 model. Conversely, the ZTP model performed worse than other models in all evaluation metrics except for AE and PRR. Figure 6 In the data, we can see that the PNZ model has the best fitting performance, followed by YID1, while the ZTP model exhibits the worst performance among all models.

[0139] Table 9. Evaluation Criterion Values ​​for Twelve Software Reliability Growth Models Using DS2-3

[0140]

[0141]

[0142] (7) Comprehensive comparison

[0143] Table 10 shows the weighted scores and rankings of the 12 software reliability growth models using DS1 and DS2 respectively. Table 11 displays the weight values ​​of the eleven evaluation criteria for the twelve software reliability growth models. Figure 7 and Figure 8 As we can clearly see, in all software testing environments, no single model outperforms the others. Although the Singhal and ZTP models have six parameters, from... Figure 7 As can be seen, the ISS model with three parameters still outperforms them, ranking first. Using DS1-1, the Singhal model ranks sixth, and the ZTP model ranks last. Figure 8In the data, we can see that the ISS model is not as good as other models. After using DS2-1, DS2-2 and DS2-3 respectively, the rankings are eleventh, twelfth and tenth.

[0144] Table 10. Ranking of twelve software reliability growth models using fault datasets DS1 and DS2 respectively.

[0145]

[0146] Table 11. Weight values ​​of the eleven model evaluation criteria

[0147]

[0148]

[0149] Secondly, the two open-source software reliability growth models showed only mediocre performance when compared using open-source failure datasets. This indicates that the testing environment for open-source software is complex and uncertain. Therefore, establishing software reliability growth models in open-source software environments is difficult and requires comprehensive consideration of development and testing environments and factors.

[0150] Finally, analysis of Table 4-9 leads to the conclusion that only by comprehensively considering the evaluation criteria can the optimal model be selected. Using different models for different software testing environments is the most reasonable and effective method for evaluating software reliability. No single model can perform well in all complex software testing environments. The optimal software reliability growth model can only exhibit optimal performance in specific environments. Our proposed method selects the optimal model by comprehensively considering the evaluation criteria and their relationships, which is a practical and effective approach.

[0151] In summary, selecting the optimal software reliability growth model is a crucial task in software reliability assessment. The chosen optimal model should be adaptable to the current software testing environment and effectively evaluate software reliability. This study uses six open-source fault datasets from two open-source software projects, eleven model evaluation criteria, and twelve software reliability growth models to validate the effectiveness of the proposed optimization model selection method. Information entropy is used as the weight in grey relational analysis to select the optimal software reliability growth model. Experimental results show that the proposed method can effectively determine a suitable software reliability growth model for the current software testing environment. Furthermore, no single model can adapt to all software testing environments. The proposed method employs weighted grey relational analysis, comprehensively considering the model evaluation criteria to select the optimal software reliability growth model. Experimental results validate the effectiveness and practicality of the proposed method.

[0152] In our future work, we plan to integrate other methods for selecting the optimal software reliability growth model, increase the number of evaluation criteria and various software reliability growth models, and enhance our ability to select the optimal model from different perspectives.

[0153] Contents not described in detail in this specification are prior art known to those skilled in the art. Although illustrative specific embodiments of the invention have been described above to facilitate understanding by those skilled in the art, it should be understood that the invention is not limited to the scope of the specific embodiments. Various modifications are readily apparent to those skilled in the art as long as they fall within the spirit and scope of the invention as defined and determined by the appended claims, and all inventions utilizing the concept of this invention are protected.

Claims

1. A method for optimizing software reliability growth models based on weighted grey relational analysis, characterized in that, Includes the following steps: Step 1, weights based on Shannon entropy; Using information from multiple evaluation criteria of the software reliability growth model, the entropy of each evaluation criterion is calculated, and then the weight values ​​are calculated, given a matrix Z with m rows and n columns as follows: In matrix Z, each row represents a different model, and each column represents the evaluation criteria used to evaluate the model. Matrix Z contains m software reliability growth models and n evaluation criteria for the models; ij Let i represent the evaluation criteria for the i-th and j-th models, where i = 1, 2, ..., m and j = 1, 2, ..., n; the specific steps for calculating the weights based on Shannon entropy are as follows: Step 1.1, standardization of matrix Z; The smaller the value of the model evaluation metric, the better the model's performance. The standardized representation of matrix Z is as follows: Conversely, the larger the criterion value of the model evaluation, the better its performance. The standardized representation of matrix Z is as follows: In the formula, q1 = 0.999999, q2 = 0.000001, and q1 + q2 = 1; S ij Let represent the i-th row and j-th column of matrix Z after standardization, where i = 1, 2, ..., m and j = 1, 2, ..., n; Step 1.2, calculate the entropy value of each model evaluation criterion in matrix Z, using the following formula: Where ln represents the logarithm to the base e; Step 1.3, the weight of each model evaluation criterion in matrix Z, is calculated using the following formula: Among them, w j This represents the weight of the model evaluation criteria in the j-th column of matrix Z; Step 2, weighted grey relational analysis method; The correlation between different sequence models is determined based on the similarity of the geometric shapes of different sequence curves. The specific steps of the weighted grey relational analysis method for selecting the software reliability growth model are as follows: Step 2.1, Equation (1) is standardized using Equation (2) or Equation (3) as follows: Among them, s mn After standardization, matrix S ij The m-th row and the n-th column; Step 2.2: Use the minimum value in each column of the matrix as the optimal evaluation criterion value, as shown below: in, Representation matrix S ij The minimum value in each column is used as the optimal evaluation standard value; the superscript 1, 2, ..., n indicates which column; Step 2.3, calculate s in equation (7). ij and The distance between each column is calculated using the formula shown below: in, Representation matrix S ij The optimal evaluation criterion value in the j-th column. Represents the matrix ΔΦ ij The minimum value in each column, Represents the matrix ΔΦ ij Maximum value in each column; Step 2.4, the grey relational coefficient is calculated as follows: Where κ represents the discrimination coefficient, and its value is 0.5; Step 2.5, the weighted grey relational degree based on Shannon entropy is shown below: Where, ρ i This represents the grey relational degree; the higher the value, the better the model's performance.

Images