Effort Estimation Problem Research Articles

Multi-kernel support vector regression with improved moth-flame optimization algorithm for software effort estimation

In this paper, a novel Moth-Flame Optimization (MFO) algorithm, namely MFO algorithm enhanced by Multiple Improvement Strategies (MISMFO) is proposed for solving parameter optimization in Multi-Kernel Support Vector Regressor (MKSVR), and the MISMFO-MKSVR model is further employed to deal with the software effort estimation problems. In MISMFO, the logistic chaotic mapping is applied to increase initial population diversity, while the mutation and flame number phased reduction mechanisms are carried out to improve the search efficiency, as well the adaptive weight adjustment mechanism is used to accelerate convergence and balance exploration and exploitation. The MISMFO model is verified on fifteen benchmark functions and CEC 2020 test set. The results show that the MISMFO has advantages over other meta-heuristic algorithms and MFO variants in terms of convergence speed and accuracy. Additionally, the MISMFO-MKSVR model is tested by simulations on five software effort datasets and the results demonstrate that the proposed model has better performance in software effort estimation problem. The Matlab code of MISMFO can be found at https://github.com/loadstar1997/MISMFO.

Automated software effort estimation for agile development system by heuristically improved hybrid learning

SummaryIn the process of modern software development, an important role is played by software effort estimation. The failure or success of the projects is mostly based on the schedule outcomes and effort estimation accuracy. The effort estimation problem still remains as a challenging issue because of the limitations of various standard measures for forecasting the efforts in the plan‐driven software development. This article emphasizes on novel software effort estimation framework using heuristically improved hybrid learning model. This article proposes heuristically improved hybrid learning (HI‐HL) with deep belief network and artificial neural network for software effort estimation. The weight optimization strategy of DBN and ANN to attain highly accurate estimation. Here, the weight optimization is performed by integrating two standard optimization algorithms such as forest optimization algorithm and moth‐flame optimization, so called as solution index‐based forest moth flame optimization with the purpose of solving the fitness function concerning the “Magnitude of Relative Error and Mean Absolute Error (MAE).” From the table results, for dataset 1, the SMAPE of SI‐FMFO‐HI‐HL is correspondingly secured 60.75%, 34.26%, 56.77%, and 61.44% improved than ELM, LSTM, DNN, and fuzzy. The simulation findings indicated that the recommended estimation model outperformed the baseline approaches on the three publically available datasets.

Locally weighted regression with different kernel smoothers for software effort estimation

• Locally Weighted Regression method provides an efficient solution to learn from local effort data. • A comprehensive experiment with 1080 Locally Weighted Regression variants has been constructed. • It has been fount that Uniform kernel functions cannot outperform non-uniform kernel functions. • Kernel type, polynomial degrees and bandwidth parameters do not produce a definite effect on estimation accuracy. • Locally Weighted Regression with Triweight or Triangle kernel outperform other complex kernels. Estimating software effort has been a largely unsolved problem for decades. One of the main reasons that hinders building accurate estimation models is the often heterogeneous nature of software data with a complex structure. Typically, building effort estimation models from local data tend to be more accurate than using the entire data. Previous studies have focused on the use of clustering techniques and decision trees to generate local and coherent data that can help in building local prediction models. However, these approaches may fall short in some aspect due to limitations in finding optimal clusters and processing noisy data. In this paper we used a more sophisticated locality approach that can mitigate these shortcomings that is Locally Weighted Regression (LWR). This method provides an efficient solution to learn from local data by building an estimation model that combines multiple local regression models in k -nearest-neighbor based model. The main factor affecting the accuracy of this method is the choice of the kernel function used to derive the weights for local regression models. This paper investigates the effects of choosing different kernels on the performance of Locally Weighted Regression of a software effort estimation problem. After comprehensive experiments with 7 datasets, 10 kernels, 3 polynomial degrees and 4 bandwidth values with a total of 840 Locally Weighted Regression variants, we found that: 1) Uniform kernel functions cannot outperform non-uniform kernel functions, and 2) kernel type, polynomial degrees and bandwidth parameters have no specific effect on the estimation accuracy. In other words, no change in bandwidth or degree values occurred with a significant difference in kernel rankings. In short, Locally Weighted Regression methods with Triweight or Triangle kernel can perform better than more complex kernels. Hence, we encourage non-uniform kernel methods as smoother function with wide bandwidth and small polynomial degree.

Application of Fuzzy Sets to the Expert Estimation of Scrum-Based Projects

The paper is basically dedicated to the problem of effort estimation for the Product Backlog items of IT projects led accordingly to the Scrum framework. The effort estimation issue is important, because low quality estimation decreases the efficiency of project implementation. The paper proposes an estimation method for the Product Backlog items of Scrum-based IT projects (which can be adapted also to other projects), which has two original elements with respect to the state of art in Scrum estimation: the usage of fuzzy numbers and strict rules for consensus forming, combined with a space for human interaction. The assumptions of the method should be complied with and were formulated on the basis of literature and authors experience. Two case studies were used for an initial method validation. The case studies confirmed a high potential of the method to increase estimation quality in Scrum-based projects, as well as in other project types. The case studies were conducted using research methods fulfilling the symmetry principle. The paper is thus an example of symmetry in management research.

Effort estimation in agile software development using experimental validation of neural network models

Frequent requirement changes are a major point of concern in today’s scenario. As a solution to such issues, agile software development (ASD) has efficiently replaced the traditional methods of software development in industries. Because of dynamics of different aspects of ASD, it is very difficult to keep track, maintain and estimate the overall product. So, in order to solve the effort estimation problem (EEP) in ASD, different types of artificial neural networks (ANNs) have been applied. This work focuses on two types of ANN-feedforward back-propagation neural network and Elman neural network. These two networks have been applied to a dataset which contains project information of 21 projects based on ASD from 6 different software houses to analyze and solve the EEP. Also, the proposed work uses three different performance metrics i.e. mean magnitude of relative error (MMRE), mean square error (MSE) and prediction (PRED(x)) to examine the performance of the model. The results of the proposed models are compared to the existing models in the literature.

Comparative analysis of soft computing techniques for predicting software effort based use case points

The size of a software project is a key measure of predicting software effort at the requirements and analysis phase. Use case points (UCP) is among software size metrics that achieved good reputation because of the increasing popularity of use case driven development methodologies in software industry. Nevertheless, there is no consistent method that can effectively translate the UCP into its corresponding effort. Previous estimation models were built using a very limited number of projects, and they were not well examined. The soft computing techniques were rarely applied for such problem and their performances have not been well investigated using a systematic procedure. This study looks into the accuracy and stability of some soft computing methods for the problem of effort estimation based on UCP. Four neural network methods, adaptive neuro fuzzy inference system and support vector regression have been used in this comparative study. The results suggest that most used soft computing techniques can work well with good accuracy for such problem. Among them, the general regression neural network is the superior one with stable ranking across different accuracy measures. Also, it has been found that using adjustment variables with basic UCP variables, solely or together, have positive impact on the accuracy and stability.

Bayesian network model for task effort estimation in agile software development

Even though the use of agile methods in software development is increasing, the problem of effort estimation remains quite a challenge, mostly due to the lack of many standard metrics to be used for effort prediction in plan-driven software development. The Bayesian network model presented in this paper is suitable for effort prediction in any agile method. Simple and small, with inputs that can be easily gathered, the suggested model has no practical impact on agility. This model can be used as early as possible, during the planning stage. The structure of the proposed model is defined by the authors, while the parameter estimation is automatically learned from a dataset. The data are elicited from completed agile projects of a single software company. This paper describes various statistics used to assess the precision of the model: mean magnitude of relative error, prediction at level m, accuracy (the percentage of successfully predicted instances over the total number of instances), mean absolute error, root mean squared error, relative absolute error and root relative squared error. The obtained results indicate very good prediction accuracy.

Evolving Software Effort Estimation Models Using Multigene Symbolic Regression Genetic Programming

Software has played an essential role in engineering, economic development, stock market growth and military applications. Mature software industry count on highly predictive software effort estimation models. Correct estimation of software effort lead to correct estimation of budget and development time. It also allows companies to develop appropriate time plan for marketing campaign. Now a day it became a great challenge to get these estimates due to the increasing number of attributes which affect the software development life cycle. Software cost estimation models should be able to provide sufficient confidence on its prediction capabilities. Recently, Computational Intelligence (CI) paradigms were explored to handle the software effort estimation problem with promising results. In this paper we evolve two new models for software effort estimation using Multigene Symbolic Regression Genetic Programming (GP). One model utilizes the Source Line Of Code (SLOC) as input variable to estimate the Effort (E); while the second model utilize the Inputs, Outputs, Files, and User Inquiries to estimate the Function Point (FP). The proposed GP models show better estimation capabilities compared to other reported models in the literature. The validation results are accepted based Albrecht data set.

Software Effort Estimation

Software development effort estimation is important for quality management in the software development industry, yet its automation still remains a challenging issue. Applying machine learning algorithms alone often cannot achieve satisfactory results. This paper presents an integrated data mining framework that incorporates domain knowledge into a series of data analysis and modeling processes, including visualization, feature selection, and model validation. An empirical study on the software effort estimation problem using a benchmark dataset shows the necessity and effectiveness of the proposed approach.

Systematic Review of Literature on Software Effort Estimation

Software effort estimation is essential to software project management. Software project managers depend on unconventional models to estimate human effort (in man months) required for completing software projects. This paper is a systematic review of classic and contemporary literature on software effort estimation. A systematic search is done across data sources to understand the issues and research problems in effort estimation problem domain.