Software Effort Estimation Using Particle Swarm Optimization with Inertia Weight

Prasad Reddy.P.V.G.D & CH.V.M.K.Hari
International Journal of Software Engineering (IJSE), Volume (2) : Issue (4) : 2011 87
Software Effort Estimation Using Particle Swarm Optimization
With Inertia Weight
Prasad Reddy.P.V.G.D prasadreddy.vizag@gmail.com
Department of Computer Science & Systems Engineering
Andhra University
Visakhapatnam, 530003, India
CH.V.M.K.Hari kurmahari@gmail.com
Department of IT
GITAM University
Visakhapatnam, 530045, India
Abstract
Software is the most expensive element of virtually all computer based systems. For complex
custom systems, a large effort estimation error can make the difference between profit and loss.
Cost (Effort) Overruns can be disastrous for the developer. The basic input for the effort
estimation is size of project. A number of models have been proposed to construct a relation
between software size and Effort; however we still have problems for effort estimation because of
uncertainty existing in the input information. Accurate software effort estimation is a challenge in
Industry. In this paper we are proposing three software effort estimation models by using soft
computing techniques: Particle Swarm Optimization with inertia weight for tuning effort
parameters. The performance of the developed models was tested by NASA software project
dataset. The developed models were able to provide good estimation capabilities.
Keywords--PM- Person Months, KDLOC-Thousands of Delivered Lines of Code, PSO - Particle
Swarm Optimization, Software Cost Estimation.
1. INTRODUCTION
The modern day software industry is all about efficiency. With the increase in the expanse and
impact of modern day software projects, the need for accurate requirement analysis early in the
software development phase has become pivotal. The provident allocation of the available
resources and the judicious estimation of the essentials form the basis of any planning and
scheduling activity. For a given set of requirements, it is desirable to cognize the amount of time
and money required to deliver the project prolifically. The chief aim of software cost estimation is
to enable the client and the developer to perform a cost – benefit analysis. The software, the
hardware and the human resources involved add up to the cost of a project. The cost / effort
estimates are determined in terms of person-months (pm) which can be easily interchanged to
actual currency cost.
The basic input parameters for software cost estimation is size, measured in KDLOC ( Kilo
Delivered Lines Of Code). A number of models have been evolved to establish the relation
between Size and Effort [13]. The parameters of the algorithms are tuned using Genetic
Algorithms [5] ,Fuzzy models[6][14], Soft-Computing Techniques[7][9][10][15], Computational
Intelligence Techniques[8],Heuristic Algorithms, Neural Networks, Radial Basis and Regression
[11][12] .
1.1 Basic Effort Model
A common approach to the estimation of the software effort is by expressing it as a single
variable function - project size. The equation of effort in terms of size is considered as follows:
Effort= a * (Size)
b
(1)

Where a, b are constants. The constants are usually determined by regression analysis applied to
historical data.
1.2 Standard PSO with Inertia Weights
In order to meet the needs of modern day problems, several optimization techniques have been
introduced. When the search space is too large to search exhaustively, population based
searches may be a good alternative, however, population based search techniques cannot
guarantee you the optimal (best) solution. We will discuss a population based search technique,
Particle Swarm Optimization (PSO) with Inertia Weights [Shi and Eberhart 1998]. Particle Swarm
has two primary operators: Velocity update and Position update. During each generation each
particle is accelerated toward the particles previous best position and the global best position. At
each iteration a new velocity value for each particle is calculated based on its current velocity, the
distance from its previous best position, and the distance from the global best position. The new
velocity value is then used to calculate the next position of the particle in the search space. The
inertia weight is multiplied by the previous velocity in the standard velocity equation and is linearly
decreased throughout the run. This process is then iterated a set number of times or until a
minimum error is achieved.
The basic concept of PSO lies in accelerating each particle towards its Pbest and Gbest locations
with regard to a random weighted acceleration at each time. The modifications of the particle’s
positions can be mathematically modeled by making use of the following equations:
Vi
k+1
= w * Vi
k
+ c1 * rand()1 * (Pbest – Si
k
) + c2 * rand()2 * (Gbest – Si
k
) (2)
Si
k+1
= Si
k
+ Vi
k+1
(3)
Where,
Si
k
is current search point,
Si
k+1
is modified search point,
Vi
k
is the current velocity,
V
k+1
is the modified velocity,
Vpbest is the velocity based on Pbest ,
Vgbest = velocity based on Gbest,
w is the weighting function,
cj is the weighting factors,
Rand() are uniformly distributed random numbers between 0 and 1.
2. THE STANDARD PSO WITH INERTIA WEIGHT FOR SOFTWARE EFFORT
ESTIMATION
The software effort is expressed as a function of a single variable as shown in equation-1. In this
parameters a, b are measured by using regression analysis applied to historical data. Now in
order to tune these parameters we use the standard PSO with inertia weights. A nonzero inertia
weight introduces a preference for the particle to continue moving in the same direction it was
going on the previous iteration. Decreasing the inertia over time introduces a shift from the
exploratory (global search) to the exploitative (local search) mode. The updating of weighting
function is done with the following formula.
Wnew = [( Tmi – Tci) * ( Wiv – Wfv) ] / Tmi + Wfv (4)
Where
Wnew is new weight factor,
Tmi is the maxium numer of iteration specified,
Tci is the current iteration number,
Wiv is the initial value of the weight,
Wfv is the final value of the weight.
Empirical experiments have been performed with an inertia weight set to decrease linearly from
0.9 to 0.4 during the course of simulation. In the first experiment we keep the parameters c1 and
c2 (weighting factors) fixed, while for the following experiment we change c1 and c2 (weighting
factors) during subsequent iterations by employing the following equations [Rotnaweera, A.
Halgamog S.K. and Watson H.C, 2004].
C1(t) = 2.5 – 2 * (t / max_iter), which is the cognitive learning factor. (5)

C2 (t) = 0.5 + 2* (t / max_iter), which is the social coefficient. (6)
The particles are initialized with random position and velocity vectors the fitness function is
evaluated and the Pbest and Gbest of all particles is found out. The particles adjust their velocity
according to their Pbest and Gbest values. This process is repeated until the particles exhaust or
some specified number of iterations takes place. The Gbest particle parameters at the end of the
process are the resultant parameters.
3. MODEL DESCRIPTION
In this model we have considered “The standard PSO with inertia weights” with /without changing
the weighting factors (c1, c2). PSO is a robust stochastic optimization technique based on the
movement of swarms. This swarm behavior is used for tuning the parameters of the Cost/Effort
estimation. As the PSO is a random weighted probabilistic model the previous benchmark data is
required to tune the parameters, based on that data, swarms develop their intelligence and
empower themselves to move towards the solution. The following is the methodology employed
to tune the parameters in each proposed models following it.
3.1 METHODOLOGY (ALOGORITHM)
Input: Size of Software Projects, Measured Efforts, Methodology (Effort Adjustment factor-EAF).
Output: Optimized Parameters for Estimating Effort.
The following is the methodology used to tune the parameters in the proposed models for
Software Effort Estimation.
Step 1: Initialize “n” particles with random positions Pi and velocity vectors Vi of tuning
parameters .We also need the range of velocity between [- Vmax,Vmax]. The Initial positions of
each particle are Personally Best for each Particle.
Step 2: Initialize the weight function value w with 0.5 and weightening parameters cognitive
learning factor c1, social coefficient c2 with 2.0.
Step 3: Repeat the following steps 4 to 9 until number of iterations specified by the user or
Particles Exhaust.
Step 4: for i = 1,2, ………, n do // For all the Particles
For each particle position with values of tuning parameters, evaluate the fitness function. The
fitness function here is Mean Absolute Relative Error (MARE). The objective in this method is to
minimize the MARE by selecting appropriate values from the ranges specified in step 1.
Step 5: Here the Pbest is determined for each particle by evaluating and comparing measured
effort and estimated effort values of the current and previous parameters values.
If fitness (p) better than fitness (Pbest) then: Pbest = p.
Step 6: Set the best of ‘Pbests’ as global best – Gbest. The particle value for which the variation
between the estimated and measured effort is the least is chosen as the Gbest particle.
Step 7: Update the weightening function is done by the following formula
Wnew = [( Tmi – Tci) * ( Wiv – Wfv) ] / Tmi + Wfv (7)
Step 8: Update the weightening factors is done with the following equations for faster
convergence.
C1(t) = 2.5 – 2 * (Tci / Tmi) (8)
C2 (t) = 0.5 + 2* (Tci / Tmi), (9)
Step 9: Update the velocity and positions of the tuning parameters with the following equations
for j = 1, 2, …………m do // For number of Parameters, our case m is 2or 3 or 4
begin
Vji
k+1
= w * Vji
k
+ c1 * rand()1 * (Pbest – Sji
k
) + c2 * rand()2 * (Gbest – Sji
k
) (10)
Sji
k+1
= Sji
k
+ Vji
k+1
(11)
end;
Step 10: Give the Gbest values as the optimal solution.
Step 11: Stop
3.2 PROPOSED MODELS
3.2.1 MODEL 1:

A prefatory approach to estimating effort is to make it a function of a single variable , often this
variable is project size measure in KDLOC ( kilo delivered lines of code) and the equation is given
as ,
Effort = a (size)b
Now in our model the parameters are tuned using above PSO methodology.
The Update of velocity and positions of Parameter “a” is
Vai
k+1
= w * Vai
k
+ c1 * rand()1 * (Pbest – Sai
k
) + c2 * rand()2 * (Gbest – Sai
k
) (12)
Sai
k+1
= Sai
k
+ Vai
k+1
The Update of velocity and positions of Parameter “b” is
Vbi
k+1
= w * Vbi
k
+ c1 * rand()1 * (Pbest – Sbi
k
) + c2 * rand()2 * (Gbest – Sbi
k
)
Sbi
k+1
= Sbi
k
+ Vbi
k+1
TABLE 1: Effort Multipliers
3.2.2 MODEL 2
Instead of having resources estimates as a function of one variable, resources estimates can
depend on many different factors, giving rise to multivariable models. Such models are useful as
they take into account the subtle aspects of each project such as their complexity or other such
factors which usually create a non linearity. The cost factors considered are shown below. The
product of all the above cost factors is the Effort Adjustment Factor (EAF).A model of this
category starts with an initial estimate determined by using the strategic single variable model
equations and adjusting the estimates based on other variable which is methodology.
The equation is,
Effort = a *(size)b
+ c* (ME).
Where ME is the methodology used in the project.
The parameters a, b, c are tuned by using above PSO methodology.
COST
FACTORS
DESCRIPTION RATING
VERY
LOW
LOW NOMINAL HIGH
VERY
HIGH
Product
RELY
Required software
reliability
0.75 0.88 1 1.15 1.4
DATA Database size - 0.94 1 1.08 1.16
CPLX Product complexity 0.7 0.85 1 1.15 1.3
Computer
TIME Execution time constraint - - 1 1.11 1.3
STOR Main storage constraint - - 1 1.06 1.21
VIRT Virtual machine volatility - 0.87 1 1.15 1.3
TURN
Computer turnaround
time
- 0.87 1 1.07 1.15
Personnel
ACAP Analyst capability 1.46 1.19 1 0.86 0.71
AEXP Application experience 1.29 1.13 1 0.91 0.82
PCAP Programmer capability 1.42 1.17 1 0.86 0.7
VEXP Virtual machine volatility 1.21 1.1 1 0.9 -
LEXP Language experience 1.14 1.07 1 0.95 -
Project
MODP
Modern programming
practice
1.24 1.1 1 0.91 0.82
TOOL Software tools 1.24 1.1 1 0.91 0.83
SCED Development schedule 1.23 1.08 1 1.04 1.1

The Update of velocity and positions of Parameter “a”, “b” are shown in Model 1 and Parameter
“c” is
Vci
k+1
= w * Vci
k
+ c1 * rand()1 * (Pbest – Sci
k
) + c2 * rand()2 * (Gbest – Sci
k
)
Sci
k+1
= Sci
k
+ Vci
k+1
3.2.3 MODEL 3
There are a lot of factors causing uncertainty and non linearity in the input parameters. In some
projects the size is low while the methodology is high and the complexity is high, for other
projects size is huge but the complexity is low. As per the above two models size and effort are
directly proportional. But such a condition is not always satisfied giving rise to eccentric inputs.
This can be accounted for by introducing a biasing factor (d). So the effort estimation equation is:
Effort = a *(size)b
+ c* (ME).+ d
a,b,c,d parameters are tuned by using above PSO methodology.
The Update of velocity and positions of Parameter “a”, “b”, “c” are shown in Model 1,2 and
Parameter “d” is
Vdi
k+1
= w * Vdi
k
+ c1 * rand()1 * (Pbest – Sdi
k
) + c2 * rand()2 * (Gbest – Sdi
k
)
Sdi
k+1
= Sdi
k
+ Vdi
k+1
4. MODEL ANALYSIS
4.1 Implementation
We have implemented the above methodology for tuning parameters a,b,c and d in “C” language.
For the parameter’ a ‘the velocities and positions of the particles are updated by applying the
following equations:
Vai
k+1
= w * Vai
k
+ c1* rand1 * (Pbesta – Sai
k
) + c2* rand2* (Gbest – Sai
k
)
Sai
k+1
= Sai
k
+ Vai
k+1
, w=0.5 , c1=c2=2.0.
and similarly for the parameters b,c and d the values are obtained for the first experiment and
weight factor w changed during the iteration and C1 and C2 are constant. For the second
experiment we changed the C1, C2 weighting factors by using equations 4 and 5.
4.2 Performance Measures
We consider three performance criterions:
1)Variance accounted – For(VAF)
2)Mean Absolute Relative Error
3)Variance Absolute Relative Error (VARE)
Where ME represents Measured Effort, EE represents Estimated Effort.
5. MODEL EXPERIMENTATION
EXPERIMENT – 1
For the study of these models we have taken data of 10 NASA [13]

TABLE 2: NASA software projects data
By running the “C” implementation of the above methodology we obtain the following parameters
for the proposed models.
Model 1 : a=2.646251 and b=0.857612 .
The range of a is [1, 10] and b is [-5,5] .
Model 2: a=2.771722, b=0.847952 and c= -0.007171.
The range of a is [1, 10], b is [-5,5] and c is [-1,1].
Model 3: a =3.131606 , b=0.820175 , c=0.045208 and d= -2.020790.
The ranges are a[1,10],b[-5,5], c[-1,1] and d[1,20].
EXPERIMENT -2:
The following are the results obtained by running the above PSO algorithm implemented in “C”
with changing weighting factors on each iteration.
Model 1: a=2.646251 and b=0.857612.
The range of a is [1,10] and b is[-5,5]
Model 2: a=1.982430, b=0.917533 and c= 0.056668.
The range of a , b, c is [1,10] , [-5,5] and [-1,1] respectively.
Model 3: a= 2.529550 , b= h0.867292 , c= -0.020757 and d=0.767248.
The ranges of a,b,c,d is [1,10] , [-5,5] , [-1,1] and [0,20] respectively.
6. RESULTS AND DISCUSSIONS
One of the objectives of the present work is to employ Particle Swarm Optimization for tuning the
effort parameters and test its suitability for software effort estimation. This methodology is then
tested using NASA dataset and COCOMO data set provided by Boehm. The results are then
compared with the models in the literature such as Baily-Basili, Alaa F. Sheta, TMF, Gbell and
Harish models. The Particle Swarm Optimization to tune parameters in Software Effort Estimation
has an advantage over the other models as the PSO process determines effective parameter
values which reduces the Mean Absolute Relative Error, which may easily be analyzed and the
implementation is also relatively easy. The following table shows estimated effort of our proposed
model:
EXPERIMENT -1:
Project No
Size In
KDLOC
Methodology
(ME)
Measured
Effort
13 2.1 28 5
10 3.1 26 7
11 4.2 19 9
17 12.5 27 23.9
3 46.5 19 79
4 54.5 20 90.8
6 67.5 29 98.4
15 78.6 35 98.7
1 90.2 30 115.8
18 100.8 34 138.3

TABLE 3: Estimated Efforts of Proposed Models
SL.
NO
SIZE
MEASU
RED
EFFORT
METHODOLOGY
ESTIMATED EFFORTOF OUR
MODELS C1,C2 ARE CONSTANT
DURING THE ITERATION (CASE-I)
ESTIMATED EFFORTOF OUR
MODELS C1,C2 ARE CHANGED
DURING THE ITERATION(CASE-II)
MODEL-I MODEL-II MODEL-III MODEL-I MODEL-II MODEL-III
1 2.1 5 28 5.000002 4.998887 5.000007 5.000002 5.502722 5.000001
2 3.1 7 26 6.982786 7.047925 7.07543 6.982786 7.071439 6.975912
3 4.2 9 19 9.060186 9.222874 8.999259 9.060186 8.47359 9.154642
4 12.5 23.9 27 23.08629 23.40447 24.05549 23.08629 21.65101 22.82118
5 46.5 79 19 71.2293 71.75396 71.84614 71.2293 68.24138 71.03909
6 54.5 90.8 20 81.61792 82.10557 82.04368 81.61792 78.82941 81.44935
7 67.5 98.4 29 98.05368 98.39988 98.39998 98.05368 96.18965 97.79541
8 78.6 98.7 35 111.7296 111.9449 111.8526 111.7296 110.7037 111.4518
9 90.2 115.8 30 125.7302 125.8721 125.048 125.7302 125.0572 125.6834
10 100.8 138.3 34 138.3002 138.3003 137.2231 138.3002 138.523 138.2999
FIGURE 1: Measured Effort Vs Estimated Efforts of Proposed Models
COMPARISON WITH OTHER MODELS
TABLE 4: Measured Efforts of Various Models
Meas
ured
effort
Bailey –
Basili
Estimate
Alaa F.
ShetaG.
E.Model
Estimate
Alaa F.
Sheta
Model 2
Estimate
Harish
model1
Harish
model2
CASE-I
MODEL-I
CASE-I
MODEL-II
CASE-I
MODEL-III
CASE-II
MODEL-I
CASE-II
MODEL-II
CASE-II
MODEL-
III
5 7.226 8.44 11.271 6.357 4.257 5.000002 4.998887 5.000007 5.000002 5.502722 5.000001
7 8.212 11.22 14.457 8.664 7.664 6.982786 7.047925 7.07543 6.982786 7.071439 6.975912
9 9.357 14.01 19.976 11.03 13.88 9.060186 9.222874 8.999259 9.060186 8.47359 9.154642
23.9 19.16 31.098 31.686 26.252 24.702 23.08629 23.40447 24.05549 23.08629 21.65101 22.82118
79 68.243 81.257 85.007 74.602 77.452 71.2293 71.75396 71.84614 71.2293 68.24138 71.03909
90.8 80.929 91.257 94.977 84.638 86.938 81.61792 82.10557 82.04368 81.61792 78.82941 81.44935
98.4 102.175 106.707 107.254 100.329 97.679 98.05368 98.39988 98.39998 98.05368 96.18965 97.79541
98.7 120.848 119.27 118.03 113.237 107.288 111.7296 111.9449 111.8526 111.7296 110.7037 111.4518

7. PERFORMANCE ANALYSIS
Model
VAF
(%)
Mean
Absolute
Relative
Error (%)
Variance
Absolute
Relative
Error (%)
Bailey –Basili Estimate 93.147 17.325 1.21
Alaa F. Sheta G.E.model I Estimate 98.41 26.488 6.079
Alaa F. Sheta Model II Estimate 98.929 44.745 23.804
Harish model1 98.5 12.17 80.859
Harish model2 99.15 10.803 2.25
CASE-I MODEL -I 98.92 4.6397 0.271
CASE-I MODEL-II 98.92 4.6122 0.255
CASE-I MODEL-III 98.9 4.4373 0.282
CASE-II MODEL -I 98.92 4.6397 0.271
CASE-II MODEL-II 98.89 7.5 0.253
CASE-II MODEL-III 98.95 4.9 0.257
TABLE 5: Performance Measures
FIGURE 2: Variance Accounted For %
115.8 140.82 131.898 134.011 126.334 123.134 125.7302 125.8721 125.048 125.7302 125.0572 125.6834
138.3 159.434 143.0604 144.448 138.001 132.601 138.3002 138.3003 137.2231 138.3002 138.523 138.2999

FIGURE 3: Mean Absolute Relative Error (MARE)
FIGURE 4: Variance Absolute Relative Error %
8 . CONCLUSION
Software cost estimation is based on a probabilistic model and hence it does not generate exact
values. However if good historical data is provided and a systematic technique is employed we
can generate better results. Accuracy of the model is measured in terms of its error rate and it is
desirable to be as close to the actual values as possible. In this study we have proposed new
models to estimate the software effort. In order to tune the parameters we use particle swarm
optimization methodology algorithm. It is observed that PSO gives more accurate results when
juxtaposed with its other counterparts. On testing the performance of the model in terms of the
MARE, VARE and VAF the results were found to be futile. These techniques can be applied to
other software effort models.

9. REFERENCES
[1] D. E. Goldberg. Genetic Algorithms in Search, Optimization and Machine Learning. Addison-
Wesley, 1989.
[2] K. Deb. Multi-Objective Optimization Using Evolutionary Algorithms. John Wiley and Sons,
2002.
[3] C.A. Coello Coello et al. Evolutionary Algorithms for Solving Multi-Objective Problems. Kluwer,
2002.
[4] Robert T. F. Ah King and Harry C. S. Rughooputh, “Elitist Multi evolutionary algorithm for
environmental/economic dispatch”, IEEE 2003.
[5] Alaa F. Sheta , “Estimation of the COCOMO Model Parameters Using Genetic Algorithms for
NASA Software Projects”, Journal of Computer Science 2 (2): 118-123, ISSN 1549-
36362006, 2006.
[6] Alaa Sheta, David Rine and Aladdin Ayesh,” Development of Software Effort and Schedule
Estimation Models Using Soft Computing Techniques”, 2008 IEEE Congress on Evolutionary
Computation (CEC 2008), DOI: 978-1-4244-1823-7/08, 2008
[7] Tad Gonsalves, Atsushi Ito, Ryo Kawabata and Kiyoshi Itoh, (2008), Swarm Intelligence in the
Optimization of Software Development Project Schedule, DOI 587
10.1109/COMPSAC.2008.179, PP: 587-592, 2008.
[8] J.S.Pahariya, V. Ravi, M. Carr (2009), Software Cost Estimation using Computational
Intelligence Techniques, IEEE Transaction, 978-1-4244-5612-3/09/PP: 849-854@2009 IEEE
[9] Parvinder S. Sandhu, Porush Bassi, and Amanpreet Singh Brar (2008), Software Effort
Estimation Using Soft Computing Techniques, PP: 488-491, 2008.
[10]Iman Attarzadeh and Siew Hock Ow (2010), Soft Computing Approach for Software Cost
Estimation, Int.J. of Software Engineering, IJSE Vol.3 No.1, PP: 1-10, January 2010.
[11]Xishi Huang, Danny Ho, Jing Ren, Luiz F. Capretz (2005), Improving the COCOMO model
using a neuro-fuzzy approach, doi:10.1016/j.asoc.2005.06.007, Applied Soft Computing 7
(2007) PP: 29–40, @2005 Elsevier.
[12]Alaa Sheta, David Rine and Aladdin Ayesh (2008), Development of Software Effort and
Schedule Estimation Models Using Soft Computing Techniques, IEEE Transaction, 978-1-
4244-1823-7/08/PP: 1283-1289@2008 IEEE.
[13]John w. Bailey and victor R.Basili,(1981) ”A meta model for software development resource
expenditures”, Fifth International conference on software Engineering, CH-1627-
9/81/0000/0107500.75@ 1981 IEEE, PP 107-129,1981.
[14]Anish M, Kamal P and Harish M, Software Cost Estimation using Fuzzy logic, ACM SIGSOFT
Software Engineering Notes,Vol.35 No.1, ,November 2010, pp.1-7
[15]Iman A and Siew H.O, Soft Computing Approach for Software Cost Estimation, Int.J. of
Software Engineering, IJSE Vol.3 No.1, January 2010, pp.1-10.

Software Effort Estimation Using Particle Swarm Optimization with Inertia Weight

Recommended

More Related Content

What's hot (17)

Viewers also liked (12)

Similar to Software Effort Estimation Using Particle Swarm Optimization with Inertia Weight (20)

More from Waqas Tariq (20)

Recently uploaded (20)

Software Effort Estimation Using Particle Swarm Optimization with Inertia Weight