# Introduction

oftware cost estimation is one of the most significant activities in software project management. It refers to the predictions of the likely amount of effort, time and staffing levels required to build a software system. The effort prediction aspect of software is made at an early stage during project development, when the costing of the project is proposed for approval. It is concerned with the prediction of the person hour required to accomplish the task. However, estimates at the early stages of the development are the most difficult to obtain because very little is known about the project and the product at the beginning. So, estimating software development effort remains a complex problem and it continues to attract research attention. There are several cost estimation techniques proposed and they are grouped into two major categories: (1) Parametric models or Algorithmic models, which uses a mathematical formula to predict project cost based on the estimates of project size, the number of software engineers, and other process and product factors [1]. These models can be built by analysing the costs and attributes of completed projects and finding the closest fit formula to actual experience. (2) Non Parametric models or Non algorithmic models which are based on fuzzy logic (FL), artificial neural networks (ANN) and evolutionary computation (EC). In this paper, we focus on non parametric cost estimation models based on artificial neural networks, and particularly Back-Propagation networks. Neural networks have learning ability and are good at modelling complex nonlinear relationships. They also provide more flexibility to integrate expert knowledge into the model. There are many software cost estimation models that have been developed using neural networks over the years. The use of radial basis function neural networks for software effort estimation is well described by many researchers [2, 3 and 4]. The clustering algorithms used in those designs are the conventional algorithms.

K. Vinay Kumar et al. [5] Uses wavelet neural networks for predicting software development cost. B. Tirimula Rao et al. [6] provided a novel neural network approach for software cost estimation using functional link artificial neural network. G. Witting and G. Finnie [7] uses back propagation learning algorithms on a multilayer perceptron in order to predict development effort. N. Karunanitthi et al. [8] reports the use of neural networks for predicting software reliability including experiments with both feed forward and Jordan networks. N. Tadayon [9] also reports the use of neural network with a back propagation learning algorithm. However it was not clear how the dataset was divided for training and validation purposes. T.M. Khoshgoftaar et al. [10] presented a case study considering real time software to predict the testability of each module from source code static measures. Ch. Satyananda Reddy and KVSVN Raju [11] proposed a cost estimation model using multi layer feed forward neural network. Venkatachalam [12] also investigated the application of artificial neural network (ANN) to software cost estimation.

Artificial neural networks are the promising techniques to build predictive models. So, there is always a scope for developing effort estimation models with better predictive accuracy. The COCOMO model, is the best known algorithmic cost model published by Barry Boehm in 1981 [1]. It was developed from the analysis of sixty three software projects. It is a hierarchy of software cost estimation models, which includes Basic, Intermediate and Detailed sub models. It was the most cited and plausible of all the traditional cost estimation models. COCOMO II is the revised version of the original COCOMO and is tuned to the life cycle practices of the 21 st century. It also provides a quantitative analytic framework, and set of tools and techniques for evaluating the effects of software technology improvements on software life cycle costs and schedules. It consists of three sub models and they are:  1 lists COCOMO II cost drivers along with their multipliers. Scale factor is a particular characteristic of the software development that has an exponential effect of increasing or decreasing the amount of development effort and they are Precedentness, Development flexibility, Architecture/Risk resolution, Team cohesion and Process maturity. These factors are rated on a six point scale i.e., very low, low, nominal, high, very high and extra high as given in Table 2. COCOMO II post architecture model is given as:
?PM = A × [ × (1)
Where PM is the effort expressed in person months, A is a multiplicative constant, size is the projected size of the software project expressed in thousands of lines of code KLOC, EM i (i=1,2....17) are effort multipliers and SF i (i=1,2....5) are exponent scale factors.


# b) Artificial Neural Networks

An artificial neural network (ANN) is an efficient information processing system which resembles in characteristics with a biological neural network. ANN's possess large number of highly interconnected processing elements called neurons. Each neuron is connected with the other by a connection link. Each connection link is associated with weights which contain information about the input signal. This information is used by the neuron net to solve a particular problem. Each neuron has an internal state of its own. This internal state is called the activation level of neuron, which is the function of the inputs the neuron receives. There are a number of activation functions that can be applied over net input such as Gaussian, Linear, Sigmoid and Tanh. It is the Sigmoid function that is the most frequently used in neural nets. Thus, the models of ANN are specified by the three basic entities namely [13]: 1. The model's synaptic interconnections; 2. The training or learning rules adopted for updating and adjusting the connection weights; 3. Their activation functions.

The neural network process starts by developing the structure of the network and establishing the technique used to train the network using an existing data set. Neural network architectures are divided into two groups: 1. Feed forward networks where no loops in the network path occur. 2. Feedback networks that have recursive loops.  The most common architecture of neural networks which is used in software cost estimation is the Back-Propagation trained Feed Forward networks [14,15]. The training algorithm of back propagation involves four stages: 1. Initialization of weights 2. Feed forward 3. Back Propagation of errors 4. Updation of the weights and biases III.


# Proposed Work

The performance of a neural network depends on its architecture and their parameter settings. There are many parameters governing the architecture of the neural network including the number of layers, the number of nodes in each layer, the transfer function in each node, learning algorithm parameters and the weights which determine the connectivity between nodes. There is no rule which determines the ideal parameter settings but even a slight parameter changes can cause major variations in the results of almost all networks. This property of the neural network is captured in the present work for predicting the software costs. The neural network model proposed is based on multi layer feed forward neural network and it uses the architecture given by Ch. Satyananda Reddy and KVSVN Raju [11]. The model accommodates the COCOMO II model.

The aim of this work is to evaluate the results of software cost estimation using COCOMO II by varying the activation functions at the input, hidden and the output layers. The model proposed uses the identity function at the input layer which is defined by The hidden and the output layer uses unipolar sigmoid function defined by .

This function is especially advantageous to use in neural networks trained by back-propagation algorithms. Because it is easy to distinguish, and this can interestingly minimize the computation capacity for training.


# a) Architecture of the Neural Network Model

The proposed structure of the neural network accommodates the COCOMO II post architecture model given by Eq. 1. The use of neural network to estimate PM (person months) in Eq. 1 requires twenty four input nodes in the input layer which corresponds to seventeen EM's, five SF's and two bias values. The COCOMO model which is a non linear model is transformed into a linear model using natural logarithms as shown in Eq. 2. 


# S.No

The above equation becomes : 
C PM = [b 1 +x 1 *
Where, C PM =ln(PM); z 1 =ln(EM 1 ); z 2 =ln(EM 2 );??;z 17 =ln(EM 17 ); z 18 =SF 1 ;??..;z 22 =SF 5 ; b 1 and b 2 are the biases and the coefficients x i and y i are the additional terms used in the model which act as the weights from the input layer to the hidden layer.

The COCOMO II model as given by Eq. 3 is shown in Fig. 1. This network consists of two hidden layer nodes C EM and C SF that take into account the contribution of effort multipliers and scale factors. C PM is the node of the output layer where we get the value of ln(PM) which is the desired output of the model. In the above network all the original EM i and SF i values of COCOMO II are pre processed to ln(EM i ) and ln(SF i ) and used as input nodes. The two bias values are denoted by b 1 and b 2 , which are ln(A) and 1.01 respectively. The size of the product is not considered as one of the inputs to the network but as a cofactor for the initial weights for scale factors (SF). The weights associated to the input nodes connected to the hidden layer are denoted by x i for for each input ln(EMi) and b 1 . On the other hand, the weights associated to the hidden layer for each ln (SFi) input nodes and b 2 are y i +ln (size) for . These weights are initialized as x i =1and y i =0. The weights from the hidden layer to the output layer are denoted by p and q and initialized as p=q=1. The feed forward back propagation procedure is used to train the network by iteratively processing a set of training samples and comparing the network's prediction with the actual value. For each training sample, the weights are modified so as to minimize the error between the networks predicted value and the actual value. The following algorithm is used for training the proposed network and for calculating the new set of weights:

Step 2: Perform steps 3-10 when stopping condition is false.

Step 3: Perform steps 4-9 for each training pair.

Step 4: Each input unit receives input signal and sends it to the hidden unit.

Step 5: Each hidden unit C EM and C SF sums its weighted input signals to calculate net input given by: 


# D

Step 1: Initialize the weights and learning rate ? ( Apply sigmoidal activation function over C EM and C SF and send the output signal from the hidden unit to the input of output layer units.

Step 6: The output unit C PM , calculates the net input given by: C PM =C EM *p+C SF *q Apply sigmoidal activation function over C PM to compute the output signal E est .

Step 7: Calculate the error correction term as: ?=E act -E est , where E act is the actual effort from the dataset and E est is the estimated effort from step 6.

Step 8: Update the weights between hidden and the output layer as:
p(new)=p(old)+ ?* ?* C EM q(new)=q(old)+ ?* ?* C SF
Step 9: Update the weights and bias between input and hidden layers as:
x i (new)=x i (old)+ ?* ? EM *z i for i=1 to 17 y i (new)=y i (old)+ ?* ? SF *z i for i=18 to 22 b 1 (new)=b 1 (old)+ ?* ? EM b 2 (new)=b 2 (old)+ ?* ? SF
The error is calculated as
? EM = ?*p; ? SF = ?*q ;
Step 10: Check for the stopping condition. The stopping condition may be certain number of epochs reached or if the error is smaller than a specific tolerance.

Using this approach, we iterate forward and backward until the terminating condition is satisfied. The variable ? used in the above formula is the learning rate, a constant, typically having a value between 0 and 1. The learning rate can be increased or decreased by the expert judgment indicating their opinion of the input effect. In other words the error should have more effect on the expert's indication that a certain input had more contribution to the error propagation or vice versa. For each project, the expert estimator can identify the importance of the input value to the error in the estimation. If none selected by the expert, the changes in the weights are as specified by the learning algorithm. The network should also be trained according to correct inputs. For example, if during estimation ACAP (Analyst Capability) is set as high but after the end of the project, the management realizes that it was nominal or low, then the system should not consider this as a network error and before training the system, the better values of cost factors should be used to identify the estimated cost.

IV.


# Datasets and Evaluation Criteria

The data sets used in the present study comes from PROMISE Software Engineering Repository data The evaluation consists in comparing the accuracy of the estimated effort with the actual effort. A common criterion for the evaluation of cost estimation model is the Magnitude of Relative Error (MRE) and is defined as in Eq. 4.


# MRE = (4)

The MRE values are calculated for each project in the validation set, while mean magnitude of relative error (MMRE) computes the average of MRE over N projects.

(5) Another evaluation criterion is MdMRE, which measures the median of all MRE's. MdMRE is less sensitive to extreme values. It exhibits a similar pattern to MMRE but it is more likely to select the true model if the underestimation is served.

Since MRE, MMRE and MdMRE are the most common evaluation criteria, they are adopted as the performance evaluators in the present paper.

V.


# Results and Discussion

This section presents and discusses the results obtained when applying the proposed neural network model to the COCOMO   Table 3 shows the results and comparison on COCOMO dataset. It also contain results given by Ch. Satyananda Reddy and KVSVN Raju [11] for the corresponding projects. For example, in the case of Project ID 5 it is 7.44   2 shows the graphical representation of MRE values for the three models for COCOMO 81 dataset. There is a decrement in the relative error using the proposed model. The results obtained thus suggest that the proposed architecture can be applied for accurately predicting the software costs.

Table 4 shows the results and comparison on NASA 93 dataset. Here also, there is a decrease in the relative error using the proposed model. For example, the relative error calculated for Project ID 30 is 8.81 for COCOMO model, and 3.34 for our proposed model. The relative error calculated for Project ID 62 is 13.2 for COCOMO model, and 5.00 for our proposed model. The Mean Magnitude of Relative Error (MMRE) for the entire validation set is 12.746 and 4.349 for the COCOMO model and our proposed model respectively. The MdMRE for the entire validation set is 13.43% for the COCOMO model and 4.46% for our proposed model. Fig. 3 shows the graphical representation of MRE values for the two models.

For COCOMO_SDR dataset, COCOMO II model performs very poorly. For Project ID 1, it has estimated effort as 2241.4 whereas the actual effort is 1 and with our proposed model it is 1.24. Similarly, for Project ID 2 COCOMO II effort is 901.6; its actual effort is 2 and the estimated is 1.95. Table 5 shows the estimated effort and their MRE values using the proposed model on COCOMO_SDR dataset. MMRE value for the estimated effort is 6.34. The MdMRE for the entire validation set is 4.62% for the proposed model. Fig. 4 shows the bar graph representation of actual effort values and estimated effort values with the proposed model for COCOMO_SDR. The bar graph shows that the estimated effort is very close to the actual effort.

The results obtained thus, suggest that the proposed model outperformed the COCOMO model and the model given by Ch. Satyananda Reddy and KVSN Raju in terms of all the discussed evaluation criteria i.e, MRE, MMRE and MdMRE. It can be applied for accurately predicting the software costs.     


# Conclusion

Software development cost estimation is a challenging task for both the industrial as well as academic communities. The accurate predictions during the early stages of development of a software project can greatly benefit the development team. There are several effort estimation models that can be used in forecasting software development effort.

In the paper, Feed Forward Back Propagation model of neural network is used which maps the COCOMO model. The model used identity function at the input layer and sigmoidal function at the hidden and output layer. The model incorporates COCOMO dataset and COCOMO NASA 2 dataset to train and to test the network. Based on the experiments performed, it is observed that the proposed model outscored COCOMO model and the model proposed by Ch. Satyananda Reddy and KVSN Raju. Future research can replicate and confirm this estimation technique with other datasets for software cost estimation. Furthermore, the utilization of other neural networks architecture can also be applied for estimating software costs. This work can also be extended using Neuro Fuzzy approach.
![Simple Neural Network Approach to Software Cost Estimation Global Journal of Computer Science and Technology Volume XIII Issue I Version I](image-2.png "A")
1![Figure 1 : Neural Network Architecture](image-3.png "Figure 1 :")
![EM = b 1 + z i *x i for i=1 to 17 C SF = b 2 + z i *(y i + ln(size)) for i=18 to 22](image-4.png "C")
![set [16] made publicly available for research purpose. The three datasets used are COCOMO 81 dataset, NASA 93 dataset and COCOMO_SDR. The COCOMO 81 dataset consists of 63 projects which uses COCOMO model as described in section 2.1. Each project is described by its 17 cost drivers, 5 scale factors, the software size measured in KDSI (Kilo Delivered Source Instructions), the actual effort, total defects and the development time in months. The NASA 93 dataset consists of 93 NASA projects from different centres for various years. It consists of 26 attributes: 17 standard COCOMO-II cost drivers and 5 scale factors in the range Very_Low to Extra_High, lines of code measure (KLOC), the actual effort in person months, total defects and the development time in months. The COCOMO_SDR dataset is from Turkish Software Industry. It consists of data from 12 projects and 5 different software companies in various domains. It has 24 attributes: 22 attributes from COCOMO II model, one being KLOC and the last being actual effort in man months. The entire dataset is divided into two sets, training set and validation set in the ratio of 80:20 to get more accuracy of prediction. The proposed model is trained with the training data and tested with the test data.](image-5.png "")
![calculated for the projects in the validation set for all the three datasets. These values are then compared with the COCOMO model.](image-6.png "D")
234![Figure 2 : Comparison of the Models on COCOMO dataset](image-7.png "Figure 2 :Figure 3 :Figure 4 :")
Application Composition Model: This model issuitable for quickly developed applications usinginteroperable components like components basedon GUI builders and is based on new object point'sestimation.? Early Design Model: This model is used in the earlystages of a software project and can be used inApplication Generator, System Integration, orInfrastructure Development Sector. It usesUnadjusted Function Points (UFP) as the measureof size.? Post Architecture Model: This is the most detailed ofthe three and is used after the overall architecturefor the project has been designed. One could usefunction points or LOC as size estimates with thismodel. It involves the actual development andmaintenance of a software product.COCOMO II describes
1
2
Cost DriverVery LowLow Nominal HighVery HighExtra High1RELY0.750.881.001.151.39--2DATA--0.931.001.091.19--3CPLX0.750.881.001.151.301.664RUSE0.911.001.141.291.495DOCU0.890.951.001.061.136TIME----1.001.111.311.677 8STOR PVOL------0.871.00 1.001.06 1.151.21 1.301.57 --013 29 10ACAP PCAP1.50 1.371.22 1.161.00 1.000.83 0.870.67 0.74----Year11PCON1.241.101.000.920.84--12AEXP1.221.101.000.890.81--13PEXP1.251.121.000.880.81--14LTEX1.221.101.000.910.84--15TOOL1.241.121.000.860.72--16SITE1.251.101.000.920.840.7817SCED1.291.101.001.001.00--Scaling FactorsVery LowLow Nominal HighVery HighExtra HighPrecedentness6.20 4.963.722.481.240.00Development Flexibility 5.07 4.053.042.031.010.00Architecture/Risk7.07 5.654.242.831.410.00ResolutionTeam Cohesion Process Maturity5.48 4.38 7.80 6.243.29 4.682.19 3.121.10 1.560.00 0.00( D D D D D D D D ) D



3S.NoProject IDMRE(%) using COCOMO modelMRE(%) using Model proposed by Satyananda ReddyMRE(%) using proposed model157.445.084.01221219.836.83.983306.493.241.7743850.9815.343.5954012.411.14.166455.354.594.0174716.410.063.468598.664.923.6796113.112.53.8610626.229.732.97116319.9512.843.53© 2013 Global Journals Inc. (US)
4
5
			© 2013 Global Journals Inc. (US)
		
		
			

				


* 
	
		Software Engineering Economics
		
			BWBoehm
		
		
			1981
			Prentice Hall
			Englewood Cliffs, NJ
		
	




* 
	
		Design of radial basis function neural networks for software effort estimation
		
			AIdri
		
		
			AZakrani
		
		
			AZahi
		
	
	
		IJCSI International Journal of Computer Science
		
			7
			4
			
			2010
		
	




* 
	
		
			AIdri
		
		
			AZahi
		
		
			EMendes
		
		
			AZakrani
		
		Software Cost Estimation Models using Radial Basis Function Neural Networks, International Conference on Software process and product measurements
				
			2007
			
		
	




* 
	
		
		
			PrasadReddy
		
		
			PV G
		
		
	




* 
	
		
		
			KSudha
		
		
			PR; Rama Sree
		
		
	




* 
	
		Software Effort Estimation using Radial Basis and Generalized Regression Neural Networks
		
			SN S V SRamesh
		
	
	
		Journal of computing
		
			2
			5
			
			2010
		
	




* 
	
		Software development cost estimation using wavelet neural networks
		
			VinayKumar
		
		
			KRavi
		
		
			VCarr; Raj Kiran
		
		
			N
		
	
	
		The Journal of Systems and Software
		
			81
			11
			
			2008
		
	




* 
	
		A Novel Neural Network Approach for Software Cost Estimation using Functional Link Artificial Neural Network (FLANN)
		
			TirimulaRao
		
		
			BSameet
		
		
			BKiran Swathi
		
		
			GVikram Gupta
		
		
			KRavi Teja
		
		
			;Ch
		
		
			SSumana
		
	
	
		International Journal of Computer Science and Network Society
		
			9
			6
			
			2009
		
	




* 
	
		Using Artificial Neural Networks and Function Points to estimate 4GL
		
			GWitting
		
		
			GFinnie
		
		
			1994
		
	




* 
	
		Software Development Effort
	
	
		Journal of Information Systems
		
			1
			2
			
		
	




* 
	
		
		
			NKarunanitthi
		
		
			DWhitely
		
		
			YKMalaiya
		
		
			1992
		
	




* 
	
		Using Neural Networks in Reliability Prediction
	
	
		IEEE Software Engineering
		
			9
			4
			
		
	




* 
	
		Predicting testability of program modules using a neural network
		
			TMKhoshgoftaar
		
		
			EBAllen
		
		
			ZXu
		
	
	
		Proceedings of 3rd IEEE Symposium on Application Specific Systems and Software Engineering Technology
				3rd IEEE Symposium on Application Specific Systems and Software Engineering Technology
		
			2000
			
		
	




* 
	
		An Improved Fuzzy Approach for COCOMO's Effort Estimation using
		
			CSReddy
		
		
			KvsnRaju
		
		
			2009
		
	




* 
	
		
	
	
		Gaussian Membership Function. Journal of software
		
			4
			5
			
		
	




* 
	
		Software Cost Estimation using artificial neural networks
		
			ARVenkatachalam
		
	
	
		Proceedings of the International Joint Conference on Neural Networks
				the International Joint Conference on Neural Networks
		
			1993
			
		
	




* 
	
		
			SNSivanandam
		
		
			SNDeepa
		
		Principles of Soft Computing
				India
		
			Wiley
			2007
		
	




* 
	
		A review of software surveys on software effort estimation
		
			KMolokken
		
		
			MJorgensen
		
	
	
		Proceedings of IEEE International Symposium on Empirical Software Engineering ISESE
				IEEE International Symposium on Empirical Software Engineering ISESE
		
			2003
			
		
	




* 
	
		Applying fuzzy neural network to estimate software development effort
		
			SHuang
		
		
			NChiu
		
	
	
		Proceedings of Applied Intelligence Journal
		
			30
			2
			
			2009