Cosine similarity-based software reliability growth model optimization selection method

Abstract

The application belongs to the technical field of software reliability growth model, and particularly relates to a method for optimizing and selecting a reliability growth model. The method mainly uses cosine similarity to divide and select an ideal software reliability growth model. The method mainly investigates the ability of cosine similarity to effectively classify categories and the adaptability of the software reliability growth model in the current software testing environment. By using the classification method of cosine similarity, the same type of software reliability growth model can be successfully selected for software reliability evaluation.

Description

TECHNICAL FIELD

[0001] The present application belongs to the technical field of software reliability growth model, and particularly relates to a method for optimizing selection of a reliability growth model. BACKGROUND

[0002] With the development of modern society, software has been applied to various businesses in human society, greatly promoting human learning and life, improving work efficiency, and reducing labor workload. However, if software failure or problems occur during operation, it will greatly affect human work and life. Software can be considered as an important tool in modern human life and business.

[0003] In order to prevent or reduce software failure after release, it is crucial to analyze software reliability before software release. However, it is difficult to accurately and effectively measure software reliability. In order to evaluate the reliability level of software, researchers have developed many software reliability growth models. Unfortunately, no software reliability growth model can be used to evaluate the reliability in all software testing scenarios. Because the development of software reliability growth model is based on the distribution of fault detection or fault introduction in actual software testing process, but its modeling assumption often does not match or because the regularity of detection or introduction of fault is inconsistent. Therefore, using a specific software reliability growth model in actual software reliability evaluation will greatly reduce the accuracy and effectiveness of evaluation.

[0004] In view of the above, researchers have investigated the use of optimal selection model to select the software reliability growth model that best fits the current software development and software reliability evaluation test environment. For example, Knaf and Sacks use maximum likelihood estimation to determine the best software reliability growth model. KHOSHGOFTAR and WOODCOCK use Akaike information criterion (AIC) to select the optimal software reliability growth model. Ullah et al. selected adaptive software reliability growth model according to model standard R2 and threshold. In addition, Sharma et al. and Yaghoobi et al. respectively use Euclidean compound distance (ECD) and Shannon entropy to determine the best software reliability growth model. Considering the advantages of ECD and Shannon entropy, Garg et al. combined ECD and Shannon entropy to select the optimal software reliability growth model.

[0005] The above optimal selection model method can effectively select the optimal model for evaluating software reliability under certain conditions. However, due to the uncertainty and complexity of software testing and development environment, and the subjectivity of fault detection, the process of fault detection and fault introduction will change complexly. In other words, during the software testing process, fault detection may exhibit different changes at different stages of software testing. For example, fault detection and fault introduction exhibit completely different changes and follow different stage distributions in the early, middle and late stages of software testing. Therefore, there is significant error and uncertainty in considering a single optimal model method to select the optimal software reliability growth model. The modeling assumptions of the selected optimal model may not necessarily conform to the regular changes in the patterns of fault detection or introduction during the actual software testing process.

[0006] To address the above challenges, the present application proposes to use cosine similarity to divide and select the ideal software reliability growth model. This optimal selection model method mainly examines the ability of cosine similarity to effectively classify categories, and the adaptability of software reliability growth models in the current software testing environment. With the classification method of cosine similarity, the same type of software reliability growth model can be successfully selected for software reliability evaluation. By avoiding the selection of software reliability growth models with modeling assumptions that do not conform to the actual testing environment and scenarios of fault detection and fault introduction during the software testing process.

[0007] The contributions of the present application are as follows:

[0008] (1) The present application proposes a classification and division method for selecting the optimal software reliability growth model.

[0009] (2) The present application proposes to use cosine similarity to divide, classify and select the optimal software reliability growth model. SUMMARY

[0010] To solve the above technical problems existing in the prior art, the present application provides a software reliability growth model optimization selection method based on cosine similarity, characterized in that it specifically comprises the following steps:

[0011] Step 1, attributes of software reliability growth model:

[0012] Suppose the attributes of the software reliability growth model are [A1, A2, …, An], and their values are [v1, v2, …, vn], and various software reliability growth models are represented as [M1, M2, …, Mm]. A matrix is used to represent the relationship between the software reliability growth model and its attributes, as shown below:

[0013]

[0014] where Mi represents the ith software reliability growth model, i takes 1~m, A j represents the jth software reliability growth model attribute, j takes 1~n;

[0015] Step 2, use cosine similarity to select the optimal model:

[0016] Step 2.1, use the cosine value of the angle between the attribute vectors of two software reliability growth models to measure the similarity of the two software reliability growth models, which is expressed as follows:

[0017]

[0018] where M1 and M2 represent two software reliability growth models respectively;

[0019] Step 2.2, considering that there are two cases when normalizing model attribute values, the first case is that the better the model performance, the smaller the model attribute value; the second case is that the larger the model attribute value, the better the performance of the model, and the normalization is represented by the following formula:

[0020] The first case:

[0021]

[0022] The second case:

[0023]

[0024] Step 2.3, normalize the matrix Mij, denoted as:

[0025]

[0026] Step 2.4, after normalizing the matrix Mij, calculate the cosine similarity using formula (2); the pseudo code is as follows:

[0027] The pseudo code of the first case:

[0028]

[0029]

[0030] The pseudo code of the second case:

[0031]

[0032] Step 2.5, add the optimal model with the optimal model attribute value to formula (5), which is expressed as follows:

[0033]

[0034] Then, the cosine similarity between each software reliability growth model and the optimized software reliability growth model is calculated.

[0035] Step 3, considering the results of step 2.4 and step 2.5, a class of optimal software reliability growth models is given.

[0036] Further, the properties of the software reliability growth model are compared using the model comparison criteria.

[0037] Further, the model comparison criteria are MSE, Bias and R 2

[0038] Compared with the prior art, the beneficial effects of the present application are as follows:

[0039] The present application proposes a cosine similarity classification method. Compared with the existing method of selecting a single optimal software reliability growth model, the proposed method uses cosine similarity to classify a class of software reliability growth models. Using multiple optimal software reliability growth models for software project reliability evaluation is more suitable for the complex environment of actual software project development and testing. Selecting the best software reliability growth model in actual software development projects makes a significant contribution to effectively evaluating software reliability. BRIEF DESCRIPTION OF DRAWINGS

[0040] Figure 1 Fig. 1 is a diagram of the cosine similarity and distance measurement of the software reliability growth model in the present application;

[0041] Figure 2 Fig. 1 is a diagram of the cosine similarity and distance measurement of the software reliability growth model in the present application;

[0042] Figure 3 Fig. 1 is a diagram of the cosine similarity and distance measurement of the software reliability growth model in the present application;

[0043] Figure 4 Fig. 1 is a diagram of the cosine similarity and distance measurement of the software reliability growth model in the present application;

[0044] Figure 5 Fig. 1 is a diagram of the cosine similarity and distance measurement of the software reliability growth model in the present application;

[0045] Figure 6 Fig. 1 is a diagram of the cosine similarity and distance measurement of the software reliability growth model in the present application; DETAILED DESCRIPTION

[0046] For the purpose of promoting the understanding of the present application, a more comprehensive description will be given below. The present application can be realized in many different forms and is not limited to the embodiments described herein. On the contrary, these embodiments are provided so as to make the disclosure of the present application more thorough and comprehensive.

[0047] Embodiment 1

[0048] The present application provides a cosine similarity-based software reliability growth model optimization selection method, characterized in that it specifically comprises the following steps:

[0049] Step 1, attribute of software reliability growth model:

[0050] Suppose the attribute of software reliability growth model is [A1, A2, …, An], and its value is [v1, v2, …, vn], and various software reliability growth models are represented as [M1, M2, …, Mm], the relationship between software reliability growth model and its attribute is represented by a matrix as follows:

[0051]

[0052] where Mi represents the i-th software reliability growth model, i takes 1~m, A j represents the j-th software reliability growth model attribute, j takes 1~n; the attribute of software reliability growth model uses model comparison standard, and the model comparison standard is MSE, Bias and R 2 .

[0053] Step 2, use cosine similarity to select the optimal model:

[0054] Step 2.1, use the cosine value of the angle between the attribute vectors of two software reliability growth models to measure the similarity of the two software reliability growth models, which is expressed by the following formula:

[0055]

[0056] where M1 and M2 represent two software reliability growth models, respectively;

[0057] Step 2.2, considering that there are two cases when normalizing the model attribute value, the first case is that the better the model performance, the smaller the model attribute value; the second case is that the larger the model attribute value, the better the performance of the model, and the normalization is represented by the following formula:

[0058] First case:

[0059]

[0060] The second case:

[0061]

[0062] Step 2.3, standardize the matrix Mij, denoted as:

[0063]

[0064] Step 2.4, after standardizing the matrix Mij, calculate the cosine similarity using formula (2);

[0065] The pseudo code is as follows:

[0066] The pseudo code of the first case is as follows:

[0067]

[0068]

[0069] The pseudo code of the second case is as follows:

[0070]

[0071] Step 2.5, add the optimal model with the optimal model attribute value to formula (5), denoted as:

[0072]

[0073] Then, calculate the cosine similarity between each software reliability growth model after standardization and the optimized software reliability growth model;

[0074] Step 3, considering the results of step 2.4 and step 2.5, give a class of optimal software reliability growth models.

[0075] Example 2

[0076] Experiment

[0077] (1) Fault data set

[0078] Use the fault data set in the literature as the first fault data set (DS1), DS1 detects 181 faults in 36 weeks. Use another fault data set in the literature as the second fault data set (DS2), DS2 detects 461 faults in 81 weeks.

[0079] To fully utilize the failure dataset to verify the effectiveness of the proposed optimization method, DS1 is divided into 80% and 100% to estimate the parameter values of the software reliability growth models, and 70% and 95% of DS2 are used to estimate the parameter values of the software reliability growth models, respectively. Then, the attribute values of the software reliability growth models are calculated. The failure dataset division ratio is random, and the purpose is to check and verify the effectiveness of the given optimization method.

[0080] (2) Multiple software reliability growth models

[0081] To verify the effectiveness of the given optimization method, multiple software reliability growth models are selected for experiments. For example, there are perfect debugging software reliability growth models (i.e., G-0, DSS, and ISS, etc.) and imperfect debugging software reliability growth models (i.e., YID1, P-Z, and P-N-Z, etc.). Consider that the failure detection obeys multiple distributions, such as exponential distribution (i.e., G-0), Weibull distribution (i.e., GGO), and S-shaped distribution (i.e., ISS). Consider that the failure introduction obeys exponential distribution (i.e., YID1) and linear change over time (i.e., YIDA2). In addition, consider the removal efficiency of failure detection (i.e., Z-T-P) and the learning phenomenon (i.e., P-Z). Table 1 provides a detailed list of various software reliability growth models.

[0082] Table 1. Multiple software reliability growth models

[0083]

[0084] (3) Software reliability growth model attributes

[0085] The model metrics are used as the attributes of the software reliability growth models, and the model comparison criteria can measure the quality of the establishment of the software reliability growth models. Various model comparison criteria comprehensively examine the fitting and prediction performance of the software reliability growth models from different aspects. Various model comparison criteria are used, such as MSE, R 2 and KD, etc. Table 2 lists various model comparison criteria (attributes) of the software reliability growth models.

[0086] Table 2. Attributes (model comparison criteria) of software reliability growth models

[0087]

[0088] (4) Software reliability growth model parameter estimation method

[0089] The least square estimation (LSE) method is used to estimate the parameters of the models. It is mainly considered that the failure dataset is a small sample, and each software reliability growth model can estimate a certain parameter value using the least square method. As shown in Table 3, the parameter values of the software reliability growth models are estimated using 80% and 100% of DS1, 70% and 95% of DS2, respectively.

[0090] Table 3 Parameter estimation values of software reliability growth models

[0091]

[0092]

[0093] (5) Experiment with failure dataset 1

[0094] An optimal model selection experiment is performed using 12 software reliability growth models, 10 model comparison criteria (model attributes), and two failure datasets. By estimating the model parameters, calculating the model attribute values, and then normalizing them, the cosine similarity is calculated. As shown in Table 4, the cosine similarity between each two models can be seen. For example, after the experiment using 80% of the failure dataset of DS1, the results are that model-1, model-6, and model-10 are classified into one class; model-2 and model-12 are classified into the same class; model-3 and model-4 belong to the same class; model-5 is similar to model-4; model-6, model-1, model-7, model-10, and model-11 are classified into one class; model-7 is similar to model-6, model-10, and model-11; model-8, model-10, and model-11 are classified into one class; model-10 is similar to model-1, model-6, model-7, and model-11; model-11 is similar to model-6, model-7, and model-10; in addition, there are many similarities between model-12 and model-2. But model-2 is not similar to other software reliability growth models.

[0095] Next, the case of cosine similarity study of software reliability growth models using 100% of the failure dataset of DS1 is performed. As shown in Table 5, the cosine similarity between each two software reliability growth models. Model-1, model-6, and model-10 are classified into one class. Model-3 is similar to model-1. Model-5 is similar to model-4. Model-6, model-1, model-7, and model-11 belong to the same class. Model-7, model-6, model-9, and model-11 are classified into one class. Model-8 is similar to model-10. Model-9, model-7, and model-11 are classified into one class. Model-10 is similar to model-1. Model-11, model-6, model-7, and model-9 are classified into one class. Model-12 is similar to model-1 and model-6. But model-2 is not similar to other software reliability growth models.

[0096] From the analysis of Table 4 and Table 5, the following conclusions can be drawn:

[0097] 1) The same type of software reliability growth model can have different similarity using different percentages of the same failure data set. For example, as shown in Table 4, Model-6 is similar to Model-10, while Model-6 is similar to Model-11.

[0098] 2) The performance of the same type of software reliability growth model can vary greatly at different testing stages.

[0099] 3) The patterns and rules of failure detection can be different at different testing stages, and the distributions they obey can also be different.

[0100] 4) The performance of the same type of software reliability growth model will be completely different throughout the testing process.

[0101] Table 4. Cosine similarity experimental results between each two models using 80% failure data set of DS1

[0102]

[0103]

[0104] Table 5. Cosine similarity experimental results between each two models using 100% failure data set of DS1

[0105] Model-1 Model-2 Model-3 Model-4 Model-5 Model-6 Model-7 Model-8 Model-9 Model-10 Model-11 Model-12 Model-1 0 0.4698 0.9956 0.5283 0.6709 1 0.9999 0.9998 0.9997 1 0.9999 0.9999 Model-2 0.4698 0 0.5161 0.5224 0.2943 0.4694 0.465 0.4769 0.4657 0.4691 0.4669 0.4639 Model-3 0.9956 0.5161 0 0.5015 0.6295 0.9954 0.9947 0.997 0.9942 0.9956 0.9948 0.9955 Model-4 0.5283 0.5224 0.5015 0 0.9276 0.53 0.5329 0.5249 0.5358 0.5273 0.533 0.5309 Model-5 0.6709 0.2943 0.6295 0.9276 0 0.6722 0.676 0.6658 0.6777 0.6704 0.6753 0.6759 Model-6 1 0.4694 0.9954 0.53 0.6722 0 1 0.9998 0.9998 0.9999 1 0.9999 Model-7 0.9999 0.465 0.9947 0.5329 0.676 1 0 0.9996 1 0.9998 1 0.9998 Model-8 0.9998 0.4769 0.997 0.5249 0.6658 0.9998 0.9996 0 0.9994 0.9999 0.9996 0.9998 Model-9 0.9997 0.4657 0.9942 0.5358 0.6777 0.9998 1 0.9994 0 0.9996 1 0.9997 Model-10 1 0.4691 0.9956 0.5273 0.6704 0.9999 0.9998 0.9999 0.9996 0 0.9998 0.9998 Model-11 0.9999 0.4669 0.9948 0.533 0.6753 1 1 0.9996 1 0.9998 0 0.9998 Model-12 0.9999 0.4639 0.9955 0.5309 0.6759 0.9999 0.9998 0.9998 0.9997 0.9998 0.9998 0

[0106] (6) Experiment with failure data set 2

[0107] Analyze Table 6 and Table 7. For example, Model-1 is similar to Model-10 in both Table 6 and Table 7, and Model-1 is also similar to Model-2, Model-4, Model-6, Model-7, Model-8, Model-11 and Model-12 as shown in Table 7. This indicates that there are different types of software reliability growth models applicable at different testing stages of the same test. The same type of software reliability growth model can exhibit different performance at different testing stages.

[0108] Based on the comprehensive comparison of Tables 4-7, it is found that the applicability of the same type of software reliability growth model is different in different test environments and stages. For example, as shown in Table 4, in the same test environment, model-12 and model-2 can be classified as a type of software reliability growth model. As shown in Table 5, in the same test environment, model-12, model-1 and model-6 can be classified as a type of software reliability growth model. Table 6 shows that model-12 and model-4 are suitable for the same test conditions. As shown in Table 7, in the same test environment, model-12, model-1, model-2, model-4, model-6, model-7, model-8, model-10 and model-11 can be classified as a type of software reliability growth model.

[0109] Table 6. Results of cosine similarity experiment between each two models using 70% failure data set of DS2

[0110] Model-1 Model-2 Model-3 Model-4 Model-5 Model-6 Model-7 Model-8 Model-9 Model-10 Model-11 Model-12 Model-1 0 0.9981 0.9921 0.9969 0.9966 0.9993 0.9999 0.9999 0.0286 1 0.9996 0.9974 Model-2 0.9981 0 0.995 0.9997 0.9997 0.9992 0.9977 0.9985 0.0342 0.9981 0.9986 0.9994 Model-3 0.9921 0.995 0 0.9933 0.9933 0.9938 0.9915 0.9929 0.0422 0.9917 0.991 0.9916 Model-4 0.9969 0.9997 0.9933 0 0.9999 0.9984 0.9963 0.9974 0.0348 0.9971 0.998 0.9998 Model-5 0.9966 0.9997 0.9933 0.9999 0 0.9984 0.9961 0.9972 0.0369 0.9967 0.9976 0.9996 Model-6 0.9993 0.9992 0.9938 0.9984 0.9984 0 0.9992 0.9996 0.0342 0.9992 0.999 0.9982 Model-7 0.9999 0.9977 0.9915 0.9963 0.9961 0.9992 0 0.9999 0.0289 0.9999 0.9994 0.9968 Model-8 0.9999 0.9985 0.9929 0.9974 0.9972 0.9996 0.9999 0 0.0299 0.9999 0.9996 0.9976 Model-9 0.0286 0.0342 0.0422 0.0348 0.0369 0.0342 0.0289 0.0299 0 0.0284 0.0281 0.0318 Model-10 1 0.9981 0.9917 0.9971 0.9967 0.9992 0.9999 0.9999 0.0284 0 0.9998 0.9976 Model-11 0.9996 0.9986 0.991 0.998 0.9976 0.999 0.9994 0.9996 0.0281 0.9998 0 0.9987 Model-12 0.9974 0.9994 0.9916 0.9998 0.9996 0.9982 0.9968 0.9976 0.0318 0.9976 0.9987 0

[0111] Table 7. Results of cosine similarity experiment between each two models using 95% failure data set of DS2

[0112] Model-1 Model-2 Model-3 Model-4 Model-5 Model-6 Model-7 Model-8 Model-9 Model-10 Model-11 Model-12 Model-1 0 1 0.9991 1 0.0289 1 1 1 0.9918 1 1 1 Model-2 1 0 0.9993 1 0.0291 1 1 1 0.9924 1 1 1 Model-3 0.9991 0.9993 0 0.9992 0.0322 0.9989 0.999 0.999 0.9959 0.9991 0.999 0.999 Model-4 1 1 0.9992 0 0.0291 1 1 1 0.9922 1 1 1 Model-5 0.0289 0.0291 0.0322 0.0291 0 0.0286 0.0289 0.0289 0.0405 0.0289 0.0289 0.0289 Model-6 1 1 0.9989 1 0.0286 0 1 1 0.9916 1 1 1 Model-7 1 1 0.999 1 0.0289 1 0 1 0.9918 1 1 1 Model-8 1 1 0.999 1 0.0289 1 1 0 0.9918 1 1 1 Model-9 0.9918 0.9924 0.9959 0.9922 0.0405 0.9916 0.9918 0.9918 0 0.9921 0.9918 0.9918 Model-10 1 1 0.9991 1 0.0289 1 1 1 0.9921 0 1 1 Model-11 1 1 0.999 1 0.0289 1 1 1 0.9918 1 0 1 Model-12 1 1 0.999 1 0.0289 1 1 1 0.9918 1 1 0

[0113] (7) Results and discussion of selecting the optimal software reliability growth model using cosine similarity

[0114] As shown in Table 8, in the case of using 80% of the failure data set of DS1, model-8 and model-10 are the best software reliability growth models that can predict the remaining number of software failures and evaluate software reliability. In addition, in the case of using 100% of the failure data set of DS1, model-12 is the best software reliability growth model. In addition, in the case of using 70% of the failure data set of DS2, model-6 is the best among all software reliability growth models. In addition, in the case of using 95% of the failure data set of DS2, model-2 and model-4 are the best software reliability growth models.

[0115] It is assumed that the properties of the optimal model (Mopt) are SSE=1, MSE=1, R2=1, RMSE=1, KD=1, TS=1, MAE=1, Variance=1, RMSPE=1 and MEOP=1. This result is not contradictory to the comparison results of cosine similarity in Tables 4-7. As shown in Tables 4-7, the similarity between each two software reliability growth models, i.e. whether they can be classified into one category in the current test environment. As shown in Table 8, which models and the optimal model belong to the same type in the current test environment. As shown in Table 8, the selected optimal software reliability growth model has good performance. Figures 2 to 5 ​

[0116] To examine the overall cosine similarity of software reliability growth models, the cosine similarity of each software reliability growth model is calculated as Figure 6

[0117] As shown in Figures 2 to 5 Figure 6, using the failure data sets of DS1 and DS2, Model-1, Model-3, Model-6, Model-7, Model-8, Model-10, Model-11 and Model-12 have relatively stable performance. Among the selected best software reliability growth models, the performance of Model-6, Model-8, Model-10 and Model-12 is very stable, except for Model-2 and Model-4, in the case of using the failure data sets of DS1 and DS2.

[0118] In summary:

[0119] 1) None of the software reliability growth models can adapt to all software testing environments.

[0120] 2) In a certain software testing environment, there can be multiple software reliability growth models that adapt to the current software testing environment.

[0121] 3) When determining the software testing environment, the selected optimal software reliability growth model can only adapt to a certain stage of software testing.

[0122] 4) Due to the complexity, uncertainty and subjectivity of software testing, the selection of the optimal software reliability growth model needs to consider the environmental and phased changes of software testing, and consider multiple software reliability growth models suitable for the current software testing situation.

[0123] Table 8. Selection results of the optimal software reliability growth model based on cosine similarity

[0124]

[0125]

[0126] (8) Conclusion

[0127] ​Cosine similarity is used to select the optimal software reliability growth model. Unlike previous optimization selection methods that only consider a single optimal model, the proposed optimization method considers a class of similar models as the optimal model. In fact, during the development and testing of software, fault detection and fault introduction exhibit different patterns and characteristics at different stages, subject to different distributions. No single model can adapt to all software testing environments and processes. Due to the complexity and uncertainty of software testing, multiple models can also adapt to the current software testing environment. To verify the effectiveness of the proposed optimization model selection method, corresponding experiments are conducted using 12 models, 10 model comparison criteria (model attributes), and two different fault datasets. The experimental results show that, at the same software testing stage, there are multiple software reliability growth models suitable for the current software testing environment. Cosine similarity can be used to effectively select a class of optimal software reliability growth models. In addition, considering the complexity of selecting an optimal software reliability growth model, future research on other classification methods will select an optimal software reliability growth model.

[0128] The technical features of the above-described embodiments can be combined in any manner. To make the description concise, not all possible combinations of the technical features in the above-described embodiments are described, but it should be considered that any combination of the technical features is within the scope of the present disclosure as long as the combination does not result in a contradiction.

Claims

1. A method for optimizing the selection of software reliability growth models based on cosine similarity, characterized in that, Specifically, the following steps are included: Step 1, Properties of the Software Reliability Growth Model: Assuming the attributes of the software reliability growth model are [A1, A2, ..., An], and their values ​​are [v1, v2, ..., vn], and the various software reliability growth models are represented as [M1, M2, ..., Mm], the relationship between the software reliability growth model and its attributes is represented using a matrix, as shown below: Where Mi represents the i-th software reliability growth model, i takes values ​​from 1 to m, and A j Let j represent the j-th attribute of the software reliability growth model, where j ranges from 1 to n; Step 2: Use cosine similarity to select the optimal model: Step 2.1: The similarity between the two software reliability growth models is measured using the cosine of the angle between their attribute vectors. The formula is as follows: Where M1 and M2 represent two software reliability growth models, respectively; Step 2.2, considering there are two cases when standardizing model attribute values: the first case is that the better the model performance, the smaller the model attribute value; the second case is that the larger the model attribute value, the better the model performance. Normalization is expressed by the following formula: First scenario: The second scenario: Step 2.3, for matrix M ij Standardize it, and represent it as: Step 2.4: After standardizing the matrix Mij, calculate the cosine similarity using formula (2); Step 2.5: Add the optimal model with the optimal model attribute values ​​to formula (5), as shown below: Then, the cosine similarity between each standardized software reliability growth model and the optimized software reliability growth model is calculated. Step 3: Taking into account the results of steps 2.4 and 2.5, an optimal software reliability growth model is given.

2. The method for optimizing the selection of software reliability growth models based on cosine similarity according to claim 1, characterized in that, The properties of the software reliability growth model are compared using model comparison criteria.

3. The method for optimizing the selection of software reliability growth models based on cosine similarity according to claim 2, characterized in that, The model comparison criteria are MSE, Bias, and R. 2 .

Images