Software cost and effort estimation using dragonfly whale optimized multilayer perceptron neural network

Software cost and time estimation is the process of estimating the cost and time required to develop a software system. Software cost and time estimation supports the planning and tracking of software projects. Effectively controlling the expensive investment of software development is one of the important issues in software project management. Estimating software development cost with high precision is still a great challenge for project managers, because it allows for considerable financial and strategic planning. Software cost estimation refers to the predictions of the likely amount of effort, time, and staffing levels required to build a software system. A very helpful form of cost estimation is the one made at an early stage during a project, when the costing of the project is proposed for approval. However, estimates at the early stages of the development are the most difficult to obtain. In this paper a novel Constructive Cost Model (COCOMO) based on soft computing approach is proposed for software cost estimation. This model carries some of the desirable features of neural networks approach, such as learning ability and good interpretability, while maintaining the merits of the COCOMO model. Unlike the standard neural networks approach, the proposed model can be interpreted and validated by experts, and has good generalisation capability. The model deals effectively with imprecise and uncertain input and enhances the reliability of software cost estimates. From the experimental results, it was concluded that, by the proposed neural network model, the accuracy of cost estimation can be improved and the estimated cost can be very close to the actual cost.

Regression techniques are used to measure software estimates accuracy for evaluation and validation. The common evaluation criteria in software engineering like Magnitude Relative Error (MRE) that computes absolute error percentage between actual and predicted efforts for reference samples is used. The Mean Magnitude Relative Error (MMRE) and Median Magnitude Relative Error (MdMRE) are the de facto standard evaluation criterion to assess the accuracy of software prediction models. The regression algorithms like M5 algorithm and Linear Regression in Software Effort Estimation using COCOMO dataset is evaluated. Simulation results demonstrate that the errors such as MMRE and MdMRE of M5 algorithm is less than linear regression in forecasting by 80.20 and 45.30 percentage respectively. Future work aims to reduce further the error of forecasting.

It is a well known fact that software effort estimation is exceptionally critical in every software industry, particular during the development of projects. It is hard to estimate the parameters involved due to ambiguity and uncertainty associated with the parameters. It is exactly here the hard limiting techniques, soft computing techniques comes to play. In this unique circumstance, this paper, presents an attempt to that compare the two paradigms for effort estimation. For this, we have considered fifty real time small visualization projects thrive by post graduate students. The prototype development involves following stages: i) Elicitation of seven novel parameters namely Lines of Code, Cumulative Grade Point Average, New and changed code, Reused code, Cyclomatic Complexity, Algorithmic Complexity and Functional Points. ii) Developing of hard limiting methods and soft computing methods for prediction of software effort involved in terms of duration in minutes.For the validation of the models error metrics namely: Mean Absolute Error (MAE), Mean Magnitude of Relative Error (MMRE), Mean of Magnitude of error Relative to the Estimate (MMER) and Root Mean Square Error (RMSE) have been used. The result showed that the models compared very well with marginal difference in terms of predict values of error matrix.

Effort estimations are a crucial aspect of software development. The tasks should be completed before the start of any software project. Accurate estimations increase the chances of project success, and inaccurate information can lead to severe issues. This study systematically reviewed the literature on effort-estimating models from 2015-2024, identifying 69 relevant studies from various publications to compile information on various software work estimation models. This review aims to analyze the models proposed in the literature and their classification, the metrics used for accuracy measurement, the leading model that has been chiefly applied for effort estimation, and the benchmark datasets available. The study utilized 542 relevant articles on software development, cost, effort, prediction, estimation, and modelling techniques in the search strategy. After 194 selections, the authors chose 69 articles to understand ML applications in SEE comprehensively. The researchers used a scoring system to assess each study’s responses (from 0 to 5 points) to their research questions. This helped them identify credible studies with higher scores for a comprehensive review aligned with its objectives. The data extraction process identified 91% (63) of 69 studies as either highly or somewhat relevant, demonstrating a successful search strategy for analysis. The literature review on SEE indicates a growing preference for ML-based models in 59% of selected studies. 17% of the studies chosen favor hybrid models to overcome software development challenges. We qualitatively analyzed all the literature on software effort estimation using expert judgment, formal estimation techniques, ML-based techniques, and hybrid techniques. We discovered that researchers have frequently used ML-based models to estimate software effort and are currently in the lead. This study also explores the application of feature importance and selection in machine learning models for Software Effort Estimation (SEE) using popular algorithms like support Vector Machine (SVM), AdaBoost (AB), Gradient Boost (GB), and Random Forest (RF) with six benchmark datasets like CHINA, COCOMO-NASA2, COCOMO, COCOMO81, DESHARNAIS, and KITCHENHAM. We analyze the dataset descriptions and feature importance of the dataset analysis using ML models for choosing crucial play attributes in SEE.

This study proposes a Function Point Analysis (FPA) based software development effort estimation methodology integrated with Use Case Diagrams. These methods include identifying actor activities, classifying those activities into FPA categories, and calculating Unadjusted Function Points (UFP). Followed by the calculation of Technical Complexity Factors (TCF) and Adjusted Function Points (AFP), this study aims to produce more accurate man-hours estimates. Results show a UFP of 162 TCF of 11, AFP of 123.12, and an estimated effort of 1846.8 hours worked, while the actual effort is 1228 hours. Evaluation of estimates using the metrics Mean Magnitude of Relative Error (MMER) 0.34, Mean Magnitude of Relative Error (MMRE) 0.50, Mean Absolute Error (MAE) 618.80, Mean Balanced Relative Error (MBRE) 0.50, Mean Inverse Balanced Relative Error (MIBRE) 0.34, and Root Mean Squared Error (RMSE) 618.80, showed sufficient precision despite the overestimation. The study suggests the need for adjustments in TCF calculations and considering development environment factors in more detail to improve estimation accuracy. These findings are essential in improving the precision of effort estimation methodologies in software development, particularly in projects that use Use Case Diagrams as the primary framework.

Software cost estimation is a process of planning, risk analysis, and decision making for project management in software development. Cost of project development encompasses a software project’s effort and development time. One popular model of software cost estimation is constructive cost model (COCOMO) model, which is a mathematical model proposed by Boehm, used for estimate the software effort and development time. The objective of this paper is to improve the basic COCOMO model’s coefficients for modern programming languages like Python, R, C++, etc. Many techniques were presented in the past for effort and time estimation using machine learning. But all these techniques were trained and tested for older programming languages. In order to improve the accuracy of COCOMO for modern programming languages, six Python projects have been considered and genetic algorithm (GA) is applied in these projects to define new values for basic COCOMO coefficients and the development time is calculated for Python projects. The time estimated using GA coefficients is compared with the original COCOMO and actual time. Using mean magnitude relative error, the error from the original COCOMO time is 54.49% and error from GA time is 21.23%.

The software cost estimation aims to predict the most realistic effort that is required to finish a software project and so it is critical to the success of a software project management. A Software Cost Estimation affects nearly all management activities, including project bidding, resource allocation and project planning. It is affected by a number of factors, such as implementation efficiency, as well as how much the various reviews and studies completed prior to the software development stage cost. Accurate cost estimation will help us to complete the project on time and within budget. Accurate estimation is important because it has led to extensive research into the methods of software cost estimation. Some important software cost estimation methods have been studied in this research work. In addition, we have set out own criteria, which has been used to compare all the different selected methods. We have also given a score for each evaluation criteria, so that we can compare the different methods numerically for cost estimation. Our observations have shown that it is best to use a number of different estimating techniques or cost models, and then compare the results before determining the reasons for any of the large variations. None of the methods are necessarily better or worse than the others. We found, in fact, that their strengths and weaknesses often complement each other. Therefore, the main conclusion is that there is no one single technique that is best for every situation, and the results of a number of different approaches need to be carefully considered to discover what is the most likely to produce estimates that are realistic.

A fuzzy logic based approach for phase-wise software defects prediction using software metrics

Software effort and cost estimation is a very important activity that includes very uncertain elements. In the context of object oriented software, traditional methods and metrics were extended to help managers in this activity. The metric use case points (UCP) is an example of metric that can be used. UCP considers functional aspects of the use case (UC) model, widely used in most organizations in the early phases of the development. However, the metric UCP presents some limitations mainly related to the granularity of the UC. To overcome these limitations, this paper introduces two metrics, also based on UCs. The first one, named USP (use case size points), considers the internal structures of the UC and better captures its functionality. The second one, named FUSP (fuzzy use case size points), considers concepts of the fuzzy set theory to create gradual classifications that better deal with uncertainty. Results from an empirical evaluation show the applicability and some advantages of the proposed metrics

Since information systems have become the heartbeat of many organizations, the investment in software is growing rapidly and consuming then a significant portion of the company budget. In this context, both the software engineering practitioners and researchers are more interested than ever about accurately estimating the effort and the quality of software product under development. Accurate estimates are desirable but no technique has demonstrated to be successful at effectively and reliably estimating software development effort. In this paper, we propose the use of an optimal trees ensemble (OTE) to predict the software development effort. The ensemble employed is built by combining only the top ranked trees, one by one, from a set of random forests. Each included tree must decrease the unexplained variance of the ensemble for software development effort estimation (SDEE). The effectiveness of the OTE model is compared with other techniques such as regression trees, random forest, RBF neural networks, support vector regression and multiple linear regression in terms of the mean magnitude relative error (MMRE), MdMRE and Pred(l) obtained on five well known datasets namely: ISBSG R8, COCOMO, Tukutuku, Desharnais and Albrecht. According to the results obtained from the experiments, it is shown that the proposed ensemble of optimal trees outperformed almost all the other techniques. Also, OTE model outperformed statistically the other techniques at least in one dataset.

Effort estimation is very important for any software development organisation. A lot of work is present for effort estimation in traditional software development but, effort estimation in agile software development (ASD) poses a great research challenge as not much of work is done in this regard. This work proposes a fuzzy approach for effort estimation in ASD environment by identifying first the cost drivers affecting the effort of agile projects and then calculating the effort using fuzzified story point approach. These cost drivers are collected through meetings and by taking a web survey from the companies in Delhi-NCR which practise ASD. Statistical tests are also performed in order to show the dependency of effort on these cost drivers. Here, fuzzy interval type-2 is used which is compared with fuzzy type-1. It is found that, the effort calculated using fuzzy interval type-2 is better than fuzzy type-1.

Accurate software cost and schedule estimation are essential for software project success. Often it referred to as the black art because of its complexity and uncertainty, software estimation is not as difficult or puzzling as people think. In fact, generating accurate estimates is straightforward -- once you understand the intensity of uncertainty and framework for the modeling process. The mystery to successful software estimation -- distilling academic information and real-world experience into a practical guide for working software professionals. Instead of arcane treatises and rigid modeling techniques, this will guide highlights a proven set of procedures, understandable formulas, and heuristics that individuals and development teams can apply to their projects to help achieve estimation proficiency with choose appropriate development approaches In the early stage of software life cycle project manager are inefficient to estimate the effort, schedule, cost estimation and its development approach. This in turn, confuses the manager to bid effectively on software project and choose incorrect development approach. That will directly effect on productivity cycle and increase level of uncertainty. This becomes a strong cause of project failure. So to avoid such problem if we know level and sources of uncertainty in model design, It will directive the developer to design accurate software cost and schedule estimation. Which are essential for software project success. However once the required efforts have estimated, little is done to recalibrate and reduce the uncertainty of the initial estimates. This paper demonstrates terminology and typology of uncertainty is presented together with a framework for the modeling process, Brief reviews have been made of 14 different (partly complementary) methods commonly used in uncertainty assessment its interaction with the broader system development process and the role of uncertainty at different stages in the modeling processes.. The applicability of these methods has been mapped according to purpose of application, stage of the modeling process and source and type of uncertainty addressed.

The importance of software estimation is utmost, as it is one of the most crucial activities for software project management. Although numerous software estimation techniques exist, the accuracy achieved by these techniques is questionable. This work studies the existing software estimation techniques for Agile software development (ASD), identifies the gap, and proposes a decentralized framework for estimation of ASD using machine‐learning (ML) algorithms, which utilize the blockchain technology. The estimation model uses nearest neighbors with four ML techniques for ASD. Using an available ASD dataset, after the augmentation on the dataset, the proposed model emits results for the completion time prediction of software. Use of another popular dataset for ASD predicts the software effort using the same proposed model. The crux of the proposed model is that it simulates blockchain technology to predict the completion time and the effort of a software using ML algorithms. This type of estimation model, using ML, making use of blockchain technology, does not exist in the literature, and this is the core novelty of this proposed model. The final prediction of the software effort integrates another technique for improving the calculated estimation, the standard deviation technique proposed by the authors previously. This model helped lessening the overall mean magnitude of relative error (MMRE) of the original model from 6.82% to 1.73% for the augmented dataset of 126 projects. All four ML techniques used for the proposed model give a better p ‐value than the original model using statistical testing through the Wilcoxon test. The average of the MMRE for effort estimation of all four techniques is below 25% on a dataset of 136 projects. The application of the standard deviation technique further helps in lessening the MMRE of the proposed model at 70%, 80%, and 90% confidence levels. The work will give insight to researchers and experts and open the doors for new research in this area.

To date studies using CBR for Web hypermedia effort prediction have not applied adaptation rules to adjust effort according to a given criterion. In addition, when applying n-fold cross-validation, their analysis has been limited to a maximum of three training sets, which according to recent studies, may lead to untrustworthy results. This paper has therefore two objectives. The first is to further investigate the use of CBR for Web hypermedia effort prediction by comparing the prediction accuracy of eight CBR techniques, of which three have previously been compared. The second objective is to compare the prediction accuracy of the best CBR technique against stepwise regression, using a twenty-fold cross-validation. All prediction accuracies were measured using Mean Magnitude of Relative Error (MMRE), Median Magnitude of Relative Error, Prediction at level 1 (1=25%), and boxplots of the residuals. One dataset was used in the estimation process and, according to all measures of prediction accuracy, stepwise regression showed the best prediction accuracy.

Accurate software effort estimation has a big importance for software companies for the reason that management of the project, control of the project, financial matters and timely deliveries are achieved with effort estimation. Thus, effort estimation plays vital role for software companies. In this study, software effort estimation is predicted by using Multilayer Perceptron and Adaptive Neuro Fuzzy Inference System. As a dataset, NASA 93 with 93 projects and Desharnais with 77 projects are used. The results show that Mean Magnitude Relative Error of Adaptive Neuro Fuzzy Inference System is lower than Multilayer Perceptron. In addition, it is seen that PRED(0.25) value of Adaptive Neuro Fuzzy Inference System is higher than Multilayer Perceptron. Thus, performance of Adaptive Neuro Fuzzy Inference System is better when compared to performance of Multilayer Perceptron.