Software Effort Estimation Methods Research Articles

Enhancing Software Effort Estimation with Pre-Trained Word Embeddings: A Small-Dataset Solution for Accurate Story Point Prediction

Traditional software effort estimation methods, such as term frequency–inverse document frequency (TF-IDF), are widely used due to their simplicity and interpretability. However, they struggle with limited datasets, fail to capture intricate semantics, and suffer from dimensionality, sparsity, and computational inefficiency. This study used pre-trained word embeddings, including FastText and GPT-2, to improve estimation accuracy in such cases. Seven pre-trained models were evaluated for their ability to effectively represent textual data, addressing the fundamental limitations of TF-IDF through contextualized embeddings. The results show that combining FastText embeddings with support vector machines (SVMs) consistently outperforms traditional approaches, reducing the mean absolute error (MAE) by 5–18% while achieving accuracy comparable to deep learning models like GPT-2. This approach demonstrated the adaptability of pre-trained embeddings for small datasets, balancing semantic richness with computational efficiency. The proposed method optimized project planning and resource allocation while enhancing software development through accurate story point prediction while safeguarding privacy and security through data anonymization. Future research will explore task-specific embeddings tailored to software engineering domains and investigate how dataset characteristics, such as cultural variations, influence model performance, ensuring the development of adaptable, robust, and secure machine learning models for diverse contexts.

Early size estimation of web apps created using codeigniter framework by nonlinear regression models

Subject matter: Early software size estimation is one of the project managers' significant problems in evaluating app development efforts because software size is the major determinant of software project effort. Function points (FPs) and lines of code (LOC) are most commonly used as measures of size in existing software effort estimation methods and models. As is known, both these metrics have their advantages and disadvantages when used for software effort estimation. Although the FPs-based measure has the advantage over the LOC in that it does not depend on the technologies used, however, the assessment of efforts requires considering such factors (environmental factors). Considering the above factors can be ensured by appropriate models for estimating the LOC-based effort. Nowadays, many Web apps are created using PHP frameworks making the app development faster. CodeIgniter is one such powerful framework. However, there are no regression models for estimating the software size of Web apps created using the CodeIgniter framework. This requires the construction of the appropriate models. The task of this paper is to develop a nonlinear regression model for estimating the software size (in KLOC, kilo lines of code) of Web apps created using the CodeIgniter framework. Method: We apply the technique for constructing nonlinear regression models based on the multivariate normalizing transformations and prediction intervals. The result is three nonlinear regression models with three predictors: the total number of classes, the average number of methods per class, and the DIT (Depth of Inheritance Tree) average per class. To build these models for estimating the size of Web apps created using the CodeIgniter framework, we used three well-known normalizing transformations: two univariate transformations (the decimal logarithm and the Box-Cox transformation) and the Box-Cox four-variate transformation. Conclusions. The nonlinear regression model constructed by the Box-Cox four-variate transformation has better size prediction results than other regression models based on the univariate transformations.

MUCPSO: A Modified Chaotic Particle Swarm Optimization with Uniform Initialization for Optimizing Software Effort Estimation

Particle Swarm Optimization is a metaheuristic optimization algorithm widely used across a broad range of applications. The algorithm has certain primary advantages such as its ease of implementation, high convergence accuracy, and fast convergence speed. Nevertheless, since its origin in 1995, Particle swarm optimization still suffers from two primary shortcomings, i.e., premature convergence and easy trapping in local optima. Therefore, this study proposes modified chaotic particle swarm optimization with uniform particle initialization to enhance the comprehensive performance of standard particle swarm optimization by introducing three additional schemes. Firstly, the initialized swarm is generated through a uniform approach. Secondly, replacing the linear inertia weight by introducing the nonlinear chaotic inertia weight map. Thirdly, by applying a personal learning strategy to enhance the global and local search to avoid trap in local optima. The proposed algorithm is examined and compared with standard particle swarm optimization, two recent particle swarm optimization variants, and a nature-inspired algorithm using three software effort estimation methods as benchmark functions: Use case points, COCOMO, and Agile. Detailed investigations prove that the proposed schemes work well to develop the proposed algorithm in an exploitative manner, which is created by a uniform particle initialization and avoids being trapped on the local optimum solution in an explorative manner and is generated by a personal learning strategy and chaotic-based inertia weight.

Toward Improving the Efficiency of Software Development Effort Estimation via Clustering Analysis

<i>Introduction</i>: The precise estimation of software effort is a significant difficulty that project managers encounter during software development. Inaccurate forecasting leads to either overestimating or underestimating software effort, which can be detrimental for stakeholders. The International Function Point Users Group&#x2019;s Function Point Analysis (FPA) method is one of the most critical methods for software effort estimation. However, the practice of using the FPA method in the same fashion across all software areas needs to be reexamined. <i>Aim</i>: We propose a model for evaluating the influence of data clustering on software development effort estimation and then finding the best clustering method. We call this model the effort estimation using machine learning applied to the clusters (EEAC) model. <i>Method</i>: We cluster the dataset according to the clustering method and then apply the FPA and EEAC methods to these clusters for effort estimation. The clustering methods we use in this study include five categorical variable criteria (Development Platform, Industrial Sector, Language Type, Organization Type, and Relative Size) and the k-means clustering algorithm. <i>Results</i>: The experimental results show that the estimation accuracy obtaining with clustering consistently outperforms the accuracy without clustering for both the FPA and EEAC methods. Significantly, using the FPA method, the average improvement rate from using clustering as opposed to non-clustered was highest at 58.06%, according to the RMSE. With the EEAC method, this number reached 65.53%. The Industry Sector categorical variable achieves the best accuracy estimation compared to the other clustering criteria and k-means clustering. The improvement in accuracy in terms of the RMSE when applying this criterion is 63.68% for the FPA method and 72.02% for the EEAC method. <i>Conclusion</i>: Better results are obtained through dataset clustering compared to no clustering for both the FPA and EEAC methods. The Industry Sector is the most suitable clustering method among the tested clustering methods.

A Review Article on Software Effort Estimation in Agile Methodology

Currently, Agile software development method has been commonly used in software development projects, and the success rate is higher than waterfall projects. The effort estimation in Agile is still a challenge because most existing means are developed based on the conventional method. Therefore, this study aimed to ascertain the software effort estimation method that is applied in Agile, the implementation approach, and the attributes that affect effort estimation. The results showed the top three estimation that is applied in Agile, are machine learning (37%), Expert Judgement (26%), and Algorithmic (21%). The implementation of all machine learning methods used a hybrid approach, which is a combination of machine learning and expert judgement, or a mix of two or more machine learning. Meanwhile, the implementation of effort estimation through a hybrid approach was only used in 47% of relevant articles. In addition, effort estimation in Agile involved twenty-four attributes, where Complexity, Experience, Size, and Time are the most commonly used and implemented.

RETRACTED ARTICLE: Hyperparameters tuning of ensemble model for software effort estimation

This article presents an effective method to improve estimation accuracy of software projects to a significant level by tuning the hyperparameters of the stacking ensemble model using evolutionary methods. Traditional and parametric methods for software effort estimation are mostly inaccurate due to bias and subjectivity. Machine Learning methods are found to be effective in dealing with bias and subjectivity issues, if the data is subjected to appropriate data pre-processing and feature extraction methods. Instead of employing a single machine learning model to estimate the software project effort, ensemble of learning models is deployed to improve the estimate. Accurate hyperparameters need to be determined to operate the ensemble model at optimised level and to reduce the errors. Hyperparameters setting is traditionally done manually according to the problem and dataset by trial and error, which is a cumbersome process. In this paper, two evolutionary approaches namely Particle Swarm Optimization (PSO) and Genetic Algorithms (GA) have been employed to tune the hyperparameters. ISBSG dataset has been used for constructing the stacking ensemble model, which is a heterogeneous dataset consisting of software project data from different countries and organizations. Experimental outcomes reveal that the accuracy of estimation is higher when the hyperparameters are tuned using PSO.

Evolutionary neural network classifiers for software effort estimation

The estimation of software development efforts has become a crucial activity in software project management. Due to this importance, many researchers focused their efforts on proposing models for relationship construction between efforts and software size and requirements. However, there are still gaps and problems in software effort's estimation process; due to the lack of enough data available in the initial stage of project life cycle. The need for an enhanced and an accurate method for software effort estimation is an urgent issue that challenged software project-management researchers around the world. This work proposes a model based on artificial neural network (ANN) and dragonfly algorithm (DA), in order to provide more accurate model for software effort estimation. The applicability of the model was evaluated using several experiments and the results were in favour of the enhancement with more accurate effort estimation.

Effort Estimation For Software Development On Mobile Application Of 'Tangkap Reptil'

An essential aspect of planning and management of software design projects is to estimate work time, costs, and human resources. The calculation solution made in this study aims to assist in calculating the estimated time of developing a reptile capture application using the Use Case Point (UCP) method. The UCP method is a software effort estimation method that shows better performance compared to other methods. The result of this research is the risk of software development on the mobile application of 'Tangkap Reptil' has a small chance, can be done in a relatively short time, and does not require a lot of resources.

KOMPARASI METODE KOMBINASI SELEKSI FITUR DAN MACHINE LEARNING K-NEAREST NEIGHBOR PADA DATASET LABEL HOURS SOFTWARE EFFORT ESTIMATION

The methods for Software Effort Estimation are divided into two, these methods are grouped into Non Machine Learning (non-ML) and Machine Learning (ML) methods [1]. The k-NN method has the disadvantage of being unable to tolerate irrelevant features and greatly affect the accuracy of k-NN. The k-NN method is also difficult to deal with missing data problems and feature categorization problems such as features that are not relevant, weight features that are not optimal, and the same features [2]. Whereas the dataset of Software Effort Estimation still has some serious challenges such as the characteristics of the data set, which are irrelevant features and the level of influence of each feature in the estimated data of the software effort [3]. This study compared the k-NN individual method with the combination of feature selection method with k-NN to find out which method was the best. The results showed that the Forward Selection (FS) method and Median Weighted Information Gain with k-Nearest Neighbor can overcome the problem of irrelevant features so as to increase accuracy in the RMSE Software Effort Estimation dataset, which is smaller in the Albrecht dataset of 5,953 using the Median method -WIG k-NN, the Miyazaki dataset is 55,421 and Kemerer is 123,081 using the FS k-NN method. The combination of kNN with Feature Selection is proven to be able to improve the estimation results better than kNN individuals. With the FS k-NN method being the best by winning in 2 datasets Miyazaki and Kemerer.

Model for improving the accuracy of relevant project selection in analogy using differential evolution algorithm

Software effort estimation is the process of calculating the effort required to develop a software product based on the input parameters that are usually partial in nature. It is an important task but the most difficult and complicated step in the software product development. Estimation requires detailed information about project scope, process requirements and resources available. Inaccurate estimation leads to financial loss and delay in the projects. Due to the intangible nature of software, most of the software estimation process is unreliable. But there is a strong relationship between effort estimation and project management activities. Various methodologies have been employed to improve the procedure of software estimation. This paper reviews journal articles on software development to get the direction in the future estimation research. Several methods for software effort estimation are discussed in this paper, including the data sets widely used and metrics used for evaluation. The use of evolutionary computational tools in the estimation is dealt with in detail. A new model for estimation using differential evolution algorithm called DEAPS is proposed and its advantages are discussed.

Regression Analysis Based Software Effort Estimation Method

Estimating the development effort of a software project in the early stages of the software life cycle is a significant task. Accurate estimates help project managers to overcome the problems regarding budget and time overruns. This paper proposes a new multiple linear regression analysis based effort estimation method, which has brought a different perspective to the software effort estimation methods and increased the success of software effort estimation processes. The proposed method is compared with standard Use Case Point (UCP) method, which is a well-known method in this area, and simple linear regression based effort estimation method developed by Nassif et al. In order to evaluate and compare the proposed method, the data of 10 software projects developed by four well-established software companies in Turkey were collected and datasets were created. When effort estimations obtained from datasets and actual efforts spent to complete the projects are compared with each other, it has been observed that the proposed method has higher effort estimation accuracy compared to the other methods.

Pareto efficient multi-objective optimization for local tuning of analogy-based estimation

Analogy-based effort estimation (ABE) is one of the prominent methods for software effort estimation. The fundamental concept of ABE is closer to the mentality of expert estimation but with an automated procedure in which the final estimate is generated by reusing similar historical projects. The main key issue when using ABE is how to adapt the effort of the retrieved nearest neighbors. The adaptation process is an essential part of ABE to generate more successful accurate estimation based on tuning the selected raw solutions, using some adaptation strategy. In this study, we show that there are three interrelated decision variables that have great impact on the success of adaptation method: (1) number of nearest analogies (k), (2) optimum feature set needed for adaptation and (3) adaptation weights. To find the right decision regarding these variables, one need to study all possible combinations and evaluate them individually to select the one that can improve all prediction evaluation measures. The existing evaluation measures usually behave differently, presenting sometimes opposite trends in evaluating prediction methods. This means that changing one decision variable could improve one evaluation measure while it is decreasing the others. Therefore, the main theme of this research is how to come up with best decision variables that improve adaptation strategy and thus the overall evaluation measures without degrading the others. The impact of these decisions together has not been investigated before; therefore, we propose to view the building of adaptation procedure as a multi-objective optimization problem. The Particle swarm optimization algorithm (PSO) is utilized to find the optimum solutions for such decision variables based on optimizing multiple evaluation measures. We evaluated the proposed approaches over 15 datasets and using four evaluation measures. After extensive experimentation, we found that: (1) predictive performance of ABE has noticeably been improved, (2) optimizing all decision variables together is more efficient than ignoring any one of them, and (3) optimizing decision variables for each project individually yields better accuracy than optimizing them for the whole dataset.

Analogy‐based effort estimation: a new method to discover set of analogies from dataset characteristics

Analogy-based effort estimation (ABE) is one of the efficient methods for software effort estimation because of its outstanding performance and capability of handling noisy datasets. Conventional ABE models usually use the same number of analogies for all projects in the datasets in order to make good estimates. The authors' claim is that using same number of analogies may produce overall best performance for the whole dataset but not necessarily best performance for each individual project. Therefore there is a need to better understand the dataset characteristics in order to discover the optimum set of analogies for each project rather than using a static k nearest projects. The authors propose a new technique based on bisecting k- medoids clustering algorithm to come up with the best set of analogies for each individual project before making the prediction. With bisecting k- medoids it is possible to better understand the dataset characteristic, and automatically find best set of analogies for each test project. Performance figures of the proposed estimation method are promising and better than those of other regular ABE models.

Impact of Modification Made in Re-UCP on Software Effort Estimation

This research work evaluates the performance of Re-UCP model and compares the results with the UCP and e-UCP method of software effort estimation. In this research work, an attempt has been made to highlight the accuracy of results by using MRE (Magnitude of Relative Error), MMRE (Mean Magnitude Relative Error), MdMRE (Median of Magnitude Relative Error) tools to check the error rate and PRED (20) and PRED (10) method to find out the predictability of accuracy of Re-UCP software effort estimation method. The observations made from the results are based on the comparison of Re-UCP, e-UCP and UCP models of software effort estimation.

Integrating uncertainty in software effort estimation using Bootstrap based Neural Networks

Software effort estimation is a crucial task in the software project management. It is the basis for subsequent planning, control, and decision-making. Reliable effort estimation is difficult to achieve, especially because of the inherent uncertainty arising from the noise in the dataset used for model elaboration and from the model limitations. This research paper proposes a software effort estimation method that provides realistic effort estimates by taking into account uncertainty in the effort estimation process. To this end, an approach to introducing uncertainty in Neural Network based effort estimation model is presented. For this purpose, bootstrap resampling technique is deployed. The proposed method generates a probability distribution of effort estimates from which the Prediction Interval associated to a confidence level can be computed. This is considered to be a reasonable representation of reality, thus helping project managers to make well-founded decisions. The proposed method has been applied on a dataset from International Software Benchmarking Standards Group and has shown better results compared to traditional effort estimation based on linear regression.

Tuning of Cost Drivers by Significance Occurrences and Their Calibration with Novel Software Effort Estimation Method

Estimation is an important part of software engineering projects, and the ability to produce accurate effort estimates has an impact on key economic processes, including budgeting and bid proposals and deciding the execution boundaries of the project. Work in this paper explores the interrelationship among different dimensions of software projects, namely, project size, effort, and effort influencing factors. The study aims at providing better effort estimate on the parameters of modified COCOMO along with the detailed use of binary genetic algorithm as a novel optimization algorithm. Significance of 15 cost drivers can be shown by their impact on MMRE of efforts on original 63 NASA datasets. Proposed method is producing tuned values of the cost drivers, which are effective enough to improve the productivity of the projects. Prediction at different levels of MRE for each project reflects the percentage of projects with desired accuracy. Furthermore, this model is validated on two different datasets which represents better estimation accuracy as compared to the COCOMO 81 based NASA 63 and NASA 93 datasets.

Active learning and effort estimation: Finding the essential content of software effort estimation data

Background: Do we always need complex methods for software effort estimation (SEE)? Aim: To characterize the essential content of SEE data, i.e., the least number of features and instances required to capture the information within SEE data. If the essential content is very small, then 1) the contained information must be very brief and 2) the value added of complex learning schemes must be minimal. Method: Our QUICK method computes the euclidean distance between rows (instances) and columns (features) of SEE data, then prunes synonyms (similar features) and outliers (distant instances), then assesses the reduced data by comparing predictions from 1) a simple learner using the reduced data and 2) a state-of-the-art learner (CART) using all data. Performance is measured using hold-out experiments and expressed in terms of mean and median MRE, MAR, PRED(25), MBRE, MIBRE, or MMER. Results: For 18 datasets, QUICK pruned 69 to 96 percent of the training data (median = 89 percent). K = 1 nearest neighbor predictions (in the reduced data) performed as well as CART's predictions (using all data). Conclusion: The essential content of some SEE datasets is very small. Complex estimation methods may be overelaborate for such datasets and can be simplified. We offer QUICK as an example of such a simpler SEE method.

AREION: Software effort estimation based on multiple regressions with adaptive recursive data partitioning

ContextAlong with expert judgment, analogy-based estimation, and algorithmic methods (such as Function point analysis and COCOMO), Least Squares Regression (LSR) has been one of the most commonly studied software effort estimation methods. However, an effort estimation model using LSR, a single LSR model, is highly affected by the data distribution. Specifically, if the data set is scattered and the data do not sit closely on the single LSR model line (do not closely map to a linear structure) then the model usually shows poor performance. In order to overcome this drawback of the LSR model, a data partitioning-based approach can be considered as one of the solutions to alleviate the effect of data distribution. Even though clustering-based approaches have been introduced, they still have potential problems to provide accurate and stable effort estimates. ObjectiveIn this paper, we propose a new data partitioning-based approach to achieve more accurate and stable effort estimates via LSR. This approach also provides an effort prediction interval that is useful to describe the uncertainty of the estimates. MethodEmpirical experiments are performed to evaluate the performance of the proposed approach by comparing with the basic LSR approach and clustering-based approaches, based on industrial data sets (two subsets of the ISBSG (Release 9) data set and one industrial data set collected from a banking institution). ResultsThe experimental results show that the proposed approach not only improves the accuracy of effort estimation more significantly than that of other approaches, but it also achieves robust and stable results according to the degree of data partitioning. ConclusionCompared with the other considered approaches, the proposed approach shows a superior performance by alleviating the effect of data distribution that is a major practical issue in software effort estimation.

Empirical Study of Homogeneous and Heterogeneous Ensemble Models for Software Development Effort Estimation

Accurate estimation of software development effort is essential for effective management and control of software development projects. Many software effort estimation methods have been proposed in the literature including computational intelligence models. However, none of the existing models proved to be suitable under all circumstances; that is, their performance varies from one dataset to another. The goal of an ensemble model is to manage each of its individual models’ strengths and weaknesses automatically, leading to the best possible decision being taken overall. In this paper, we have developed different homogeneous and heterogeneous ensembles of optimized hybrid computational intelligence models for software development effort estimation. Different linear and nonlinear combiners have been used to combine the base hybrid learners. We have conducted an empirical study to evaluate and compare the performance of these ensembles using five popular datasets. The results confirm that individual models are not reliable as their performance is inconsistent and unstable across different datasets. Although none of the ensemble models was consistently the best, many of them were frequently among the best models for each dataset. The homogeneous ensemble of support vector regression (SVR), with the nonlinear combiner adaptive neurofuzzy inference systems-subtractive clustering (ANFIS-SC), was the best model when considering the average rank of each model across the five datasets.

On the Value of Ensemble Effort Estimation

Background: Despite decades of research, there is no consensus on which software effort estimation methods produce the most accurate models. Aim: Prior work has reported that, given M estimation methods, no single method consistently outperforms all others. Perhaps rather than recommending one estimation method as best, it is wiser to generate estimates from ensembles of multiple estimation methods. Method: Nine learners were combined with 10 preprocessing options to generate 9 \times 10 = 90 solo methods. These were applied to 20 datasets and evaluated using seven error measures. This identified the best n (in our case n=13) solo methods that showed stable performance across multiple datasets and error measures. The top 2, 4, 8, and 13 solo methods were then combined to generate 12 multimethods, which were then compared to the solo methods. Results: 1) The top 10 (out of 12) multimethods significantly outperformed all 90 solo methods. 2) The error rates of the multimethods were significantly less than the solo methods. 3) The ranking of the best multimethod was remarkably stable. Conclusion: While there is no best single effort estimation method, there exist best combinations of such effort estimation methods.