IEEE/CAA JOURNAL OF AUTOMATICA SINICA, VOL. 6, NO.

6, NOVEMBER 2019 1365

Forecasting of Software Reliability Using Neigh-

borhood Fuzzy Particle Swarm Optimization
Based Novel Neural Network
Pratik Roy, Student Member, IEEE, Ghanshaym Singha Mahapatra, and Kashi Nath Dey

Abstract — This paper proposes an artificial neural network itive-to-use software. Hence, software must need to be reli-
(ANN) based software reliability model trained by novel particle able and fault free. The main objective is to develop software
swarm optimization (PSO) algorithm for enhanced forecasting of
the reliability of software. The proposed ANN is developed con- products with high reliability and superior quality in a well-
sidering the fault generation phenomenon during software testing timed approach. As software artifacts are growing fast in com-
with the fault complexity of different levels. We demonstrate the plexity with size, accurate assessment of software reliability
proposed model considering three types of faults residing in the becomes most challenging assignment for good quality soft-
software. We propose a neighborhood based fuzzy PSO al- ware development. Software reliability assessment is one of
gorithm for competent learning of the proposed ANN using soft- the significant concern of today’s complex software develop-
ware failure data. Fitting and prediction performances of the
neighborhood fuzzy PSO based proposed neural network model ment process for estimation and prediction of the reliability
are compared with the standard PSO based proposed neural net- and performance of software. As stated by ANSI, “software
work model and existing ANN based software reliability models reliability is defined as the probability of failure-free software
in the literature through three real software failure data sets. We operation for a specified period of time in a specified environ-
also compare the performance of the proposed PSO algorithm ment” [1]. Software reliability is the most significant metric
with the standard PSO algorithm through learning of the pro-
for software quality as well as an essential issue for determin-
posed ANN. Statistical analysis shows that the neighborhood
fuzzy PSO based proposed neural network model has comparat- ation of the software testing time span.
ively better fitting and predictive ability than the standard PSO During the last three decades, many software reliability
based proposed neural network model and other ANN based growth models (SRGMs) have been proposed as a tool to
software reliability models. Faster release of software is achiev- predict the relationship between software failure and software
able by applying the proposed PSO based neural network model testing time. SRGMs use software failure time data to
during the testing period.
recognize whether the software reliability is increasing
Index Terms—Artificial neural network (ANN), fuzzy, particle satisfactorily to achieve the desired software requirements
swarm optimization (PSO), reliability prediction, software reliability. specifications. Software reliability models are extremely
helpful in the sense that they help testing engineers to make
I. Introduction critical decisions, such as the testing resource allocation and
OMPUTER systems are broadly employed in different
C areas of our modern civilization. Computer is governed
by software which provides a basis by which we can interact
the software release time estimation [2]. Software reliability
models are categorized into parametric models and non-
parametric models. Parameters of the parametric models are
with the computer and accomplish our task. Nowadays, soft- estimated according to the assumptions about the behavior of
ware is a vital constituent of various safety-critical and life- the failure processes and development environments of the
critical application systems that often require extremely rigor- software. Popular statistical parametric models are the
ous certification process. People forever require easy and intu- nonhomogeneous poisson process (NHPP) based SRGMs
Manuscript received October 1, 2018; revised January 25, 2019, March 11, [3]–[11]. However, one of the difficulties of using parametric
2019, accepted April 16, 2019. This work was supported by the Council of SRGMs is the presence primary assumptions which are
Scientific and Industrial Research of India (09/028(0947)/2015-EMR-I). Re- sometimes hard to validate and causes obscurity in selecting
commended by Associate Editor Shun-Feng Su. (Corresponding author:
Pratik Roy.)
the most appropriate model for real project. Although
Citation: P. Roy, G. S. Mahapatra, and K. N. Dey, “Forecasting of soft- numerous research works have been carried out to improve
ware reliability using neighborhood fuzzy particle swarm optimization based the prediction accuracy of parametric SRGMs, it has been
novel neural network,” IEEE/CAA J. Autom. Sinica, vol. 6, no. 6, pp. shown that none single model is still existing to be trusted to
1365–1383, Nov. 2019.
produce always precise prediction results in all software
P. Roy and K. N. Dey are with the Department of Computer Science and
Engineering, University of Calcutta, Kolkata-700106, India (e-mail: development environments [12]. Conversely, non-parametric
pratik.roy.1988@ieee.org; kndey55@gmail.com). models such as the ANN based models have the flexibility to
G. S. Mahapatra is with the Department of Mathematics, National Institute predict software reliability derived from only fault history data
of Technology, Puducherry, Karaikal-609609, India (e-mail: gs.mahapatra@
nitpy.ac.in).
without any assumptions about the failure processes. It is
Color versions of one or more of the figures in this paper are available on- shown that ANN based non-parametric software reliability
line at http://ieeexplore.ieee.org. models have better prediction capability than the parametric
Digital Object Identifier 10.1109/JAS.2019.1911753 models [13]–[15]. Various types of ANNs have been proposed
1366 IEEE/CAA JOURNAL OF AUTOMATICA SINICA, VOL. 6, NO. 6, NOVEMBER 2019

for prediction of the cumulative number of detected faults The rest of the paper is structured as follows: Section II
where the execution time is applied as input to the network. describes some related works about the application of ANNs
Different techniques have been proposed to combine various in software reliability modeling and prediction as well as
existing software reliability models to develop weighted different variants of PSO algorithm proposed in current years.
combinational model with enhanced predictive capability than Section III presents two fault generation based statistical
the component models [13], [16]. ANN based software parametric SRGMs. In Section IV, we propose the ANN
reliability model has been developed considering the existence based model for software reliability prediction and describe
of different types of faults in the software with learning the software release time policy based on the reliability. In
phenomenon [15]. Section V, we propose the neighborhood based fuzzy PSO
PSO algorithm, one of the most popular evolutionary algorithm for learning of the proposed ANN based software
computing techniques based on artificial life and social reliability model. Section VI describes the characteristics of
psychology, was pioneered by Kennedy and Eberhart [17]. the software failure data sets employed for validation of the
PSO [18] is a nature-inspired population based metaheuristic proposed model. Model performance comparison criteria are
optimization technique. Here, a swarm is described by a presented in Section VII. Section VIII shows the experimental
population of particles and each particle represents a possible results through various tabular and graphical representations
solution of an optimization problem. Every particle in the based on the three real software failure data sets. Finally,
swarm adjusts search patterns based on its personal experience conclusions are made in Section IX.
and the experience of other particles in the swarm. Traditional
PSO algorithm has fast convergence rate. But it undergoes II. Literature Survey
early convergence problem, i.e., it can be trapped into local This section illustrates the associated works where different
optima when solving complex multimodal problems. types of ANN [27] have been employed for software
Recently, different variations of PSO algorithm [19]–[25] reliability prediction. We also describe the related works
have been proposed to attain good convergence speed and to about the variants of PSO algorithm that have been attracted
avoid trapping in local optima which make PSO as an efficient in current years.
black-box optimizer for real parameter optimization problems Karunanithi et al. [28] proposed ANN for prediction of
over continuous search space. PSO algorithm has been software reliability employing the testing time as the input and
effectively used in artificial neural network learning and the cumulative number of detected faults as the desired output
function optimization [26]. of the ANN. Cai et al. [29] proposed ANN trained by back-
In this paper, we propose an ANN based software reliability propagation algorithm for prediction of the software reliability
model incorporating the impact of fault generation using recent 50 inter-failure times as input for prediction of
phenomenon with different levels of fault complexity. We the next failure time. Ho et al. [30] proposed modified
demonstrate the proposed model for software containing recurrent neural network for modeling and prediction of
simple, hard and complex faults. We also propose a novel software failures. Tian and Noore [31] proposed evolutionary
neighborhood based fuzzy PSO algorithm for learning of the ANN for cumulative software failure time prediction based on
proposed ANN by the software failure data. The proposed multiple-delayed-input single-output architecture. Su and
neighborhood based learning strategy of the PSO algorithm Huang [13] proposed ANN based dynamic weighted
considers the local best particle in the neighborhood of a combination model to predict software reliability. Hu et al.
particle instead of the global best particle in the velocity [32] proposed recurrent neural network to model the fault
updating rule to avoid trapping in local optima. We use ring detection and correction processes collectively. Kiran and
topology for the implementation of the neighborhood. We Ravi [33] proposed non-linear ensemble approach for
consider fuzzy adaptive nature of the PSO parameters to prediction of software reliability. Kapur et al. [15] proposed
improve the searching accuracy and efficiency of the PSO ANN based generalized dynamic integrated model
algorithm such that it cannot be ensnared in local optima. We incorporating learning phenomenon with faults of different
compare the fitting and prediction performances of the complexity. Zheng [14] proposed an ensemble of ANNs for
neighborhood fuzzy PSO based proposed neural network prediction of software reliability. Kapur et al. [34] proposed
model (FPSONNM) with the standard PSO based proposed an ensemble of different ANNs to enhance the reliability
neural network model (PSONNM) and existing flexible estimation accuracy for complex software architectures.
generalized dynamic integrated model [15], dynamic weighted Mohanty et al. [35] proposed novel recurrent architectures
combinational model [13] and neural network ensembles based on genetic programming and group method of data
model [14] in the software reliability literature. Three real handling for prediction of software reliability. Arar and Ayan
software failure data sets are employed to validate the [36] proposed a classification approach using traditional ANN
effectiveness of the proposed model. The performance of the and novel artificial bee colony algorithm in software defect
proposed neighborhood based fuzzy PSO algorithm is also prediction problem. Roy et al. [37] proposed an ANN based
compared with the standard PSO algorithm through learning dynamic weighted combination model trained by
of the proposed ANN. Optimal software release times are neighborhood-based adaptive PSO algorithm for software
evaluated for different time increments based on achieving a reliability prediction.
predefined level of software reliability using the various Currently, different variations of PSO algorithm have been
software reliability models under comparison. proposed. Shi and Eberhart [38] introduced a parameter
ROY et al.: FORECASTING OF SOFTWARE RELIABILITY USING NEIGHBORHOOD FUZZY PSO BASED NOVEL NEURAL NETWORK 1367

ai ( )
referred to as the inertia weight to equilibrate local mi (t) = 1 − e−bi (1−αi )t , i = 1, 2, 3. (5)
exploitation and global exploration. This variant is called 1 − αi
standard PSO algorithm. Naisr et al. [20] proposed dynamic Hence, mean value function of the SRGM is specified as
neighborhood learning particle swarm optimizer where the follows:
velocity of a particle is updated using the historical best
∑
3 ∑3
ai ( )
information of all other particles within the swarm choosing m(t) = mi (t) = 1 − e−bi (1−αi )t (6)
the exemplar particle from a neighborhood. Wang et al. [21] i=1 i=1
1 − αi
proposed a diversity enhanced PSO with neighborhood search where ai is the initial number of ith type of fault in the soft-
to attain a trade-off between exploration and exploitation ware.
capabilities. Xu [22] proposed velocity based parameter
tuning of PSO algorithm. Juang et al. [24] proposed adaptive IV. Proposed ANN Based Software Reliability Model
fuzzy PSO algorithm derived from the standard PSO We propose a feedforward ANN-based software reliability
algorithm. Niknam [23] proposed a fuzzy adaptive PSO model considering the consequence of fault generation
algorithm for solving economic dispatch problem. Marinakis phenomenon to estimate and predict the reliability of software
et al. [39] proposed hybrid PSO algorithm with variable containing n different types of faults. We consider two events,
neighborhood search for solving constrained shortest path i.e., fault complexity and fault generation to develop the ANN
problem. C. Jin and S. W. Jin [40] proposed quantum particle design. The proposed ANN-based model has been developed
swarm optimization algorithm to optimize the parameters of associating the effect of fault generation with different levels
the SRGM with testing-effort function. Naderi et al. [25] of fault complexity. We have developed the ANN so that it is
proposed a novel fuzzy adaptive heterogeneous useful for reliability forecasting of software containing
comprehensive-learning PSO algorithm with enhanced different (n) kinds of faults depending upon their complexity.
exploration and exploitation processes to solve the optimal We have also incorporated the impact of fault generation to
reactive power dispatch problem. construct the ANN so that the model can be applied to a
variety of failure data sets. The proposed feedforward ANN
III. Review of Statistical Parametric SRGMs
architecture is shown in Fig. 1.
In this section, we present two most popular fault generation
based statistical parametric SRGMs. 1

A. Fault Generation Model w11 w21

w12 2 w22
Ohba and Chou [8] proposed SRGM considering the effect
of fault generation. The model assume constant fault ti yi′(ti)
generation rate α. The following equations represent failure w1n w2n
phenomenon of the model:
n
dm(t) Input layer Hidden layer Output layer
= b(t)[a(t) − m(t)] with b(t) = b, a(t) = a + αm(t) (1)
dt
where a(t) is fault content function of the software and b(t) is Fig. 1. ANN architecture of proposed model for n types of faults.
fault detection rate function. Here, a is the expected initial
number of faults and b is the constant fault detection rate. The proposed ANN is constructed with single hidden layer
Solving (1) under the initial condition m(0) = 0 , we get the and one neuron in the input and output layer but multiple
mean value function m(t) of the SRGM as follows: neurons in the hidden layer. Here, number of neurons in the
hidden layer is dependent on types of faults that exist in the
a ( )
m(t) = 1 − e−b(1−α)t . (2) software. For software comprising n different types of faults
1−α according to their complexity, the network has n hidden layer
neurons. Cumulative software execution time (ti) is input of
B. Fault Generation Model Incorporating Fault Complexity
the ANN and predicted cumulative number of detected
Lynch et al. [9] considered three types of software faults in ′
software failures at execution time ti(yi (ti )) is the output of the
the fault generation SRGM proposed by Ohba and Chou [8]. ANN, where i is the cumulative software execution time
Fault detection rates are defined by bi, i = 1, 2, 3 for simple, sequence index. Practically, we can design various activation
hard and complex faults respectively. The model is functions for different neurons of the hidden layer. To
characterized by following two differential equations: accommodate the impact of fault generation in presence of
dmi (t) faults of different complexity, the general functional form of
= bi [ai (t) − mi (t)] (3) the activation functions for hidden layer neurons is defined as
dt
follows:
dai (t) dmi (t)
= αi . (4) 1 ( )
dt dt ϕ j (x) = 1 − e−p j x , j = 1, 2, ..., n (7)
Solving (3) and (4) under initial conditions ai (0) = ai and pj
mi (0) = 0, mean value function for simple, hard and complex where p j ( j = 1, 2, ..., n) is the activation function parameter
faults is obtained as follows: for the jth neuron in the hidden layer. Linear activation func-
1368 IEEE/CAA JOURNAL OF AUTOMATICA SINICA, VOL. 6, NO. 6, NOVEMBER 2019

tion f (x) = x is used for the single output layer neuron. Here, software. In DWCM, a single layer feedforward ANN is
w1 j , w2 j ( j = 1, 2, ..., n) are weights assigned in the ANN from constructed for software reliability prediction. This is a
the input to hidden layer and hidden to output layer respect- combinational model which combines three traditional
ively. There is no bias in the hidden and output layer neurons. statistical SRGMs. The hidden layer has three neurons
Input to the jth neuron of hidden layer is specified by corresponding to three models. NNEM predicts software
reliability based on neural network ensembles. A number of
I j = w1 j ti , j = 1, 2, ..., n. (8)
single layer feedforward ANNs with a certain number of
The activation function ϕ j (x) determines the outputs from hidden layer neurons in each network is ensembled for
the hidden layer neurons. Output of the jth neuron in hidden software reliability prediction. As opposed to these models,
layer is evaluated as follows: the proposed ANN has the ability to predict reliability of
1 ( ) software having different (n) types of faults in fault generation
O j = ϕ j (I j ) = ϕ j (w1 j ti ) = 1 − e−p j w1 j ti , environment based on only fault history data without any
pj
assumptions about the failure processes and development
j = 1, 2, ..., n. (9)
environment.
Hence, input to the single output layer neuron is given by
A. An Application
∑
n ∑
n
w2 j ( )
−p j w1 j ti
I= w2 j O j = 1−e . (10) Now we demonstrate the proposed model for software
j=1 j=1
pj containing simple, hard and complex faults. Graphical
Now activation function f (x) determines the output from the architecture of the ANN for three types of faults is shown in
single output layer neuron of the network. Hence, output of Fig. 2.
the proposed ANN is determined as follows:
  1
∑ n
w2 j ( ) w11 w21
yi (ti ) = f (I) = f 
′  1 − e j 1 j i 
−p w t
p j
j=1 w12 w22
2
∑
n
w2 j ( ) ti yi′(ti)
= 1 − e−p j w1 j ti . (11) w13 w23
j=1
pj

Here, the values of the network weights w1j, w2j (j = 3

1,2,...,n) are evaluated dynamically through the learning of the Input layer Hidden layer Output layer

proposed ANN based on the characteristics of failure data sets

Fig. 2. ANN architecture of proposed model for three types of faults.
applied to train the ANN. The values of the hidden layer
activation function parameter p j ( j = 1, 2, ..., n) are also The ANN has single neuron in each of the input and output
evaluated by the learning algorithm. layers and three neurons in the single hidden layer
In (11), if we replace the weights w1 j by b j (fault detection
representing three types of faults in the software. The
rate for jth class of fault), j = 1, 2, ..., n, w2 j by a j (initial fault
activation functions for the three hidden layer neurons can be
content of jth type of fault),( j = 1,) 2, ..., n and the activation
obtained from (7) as follows:
function parameter p j by 1 − α j (where α j is the fault
generation rate of jth class of fault), j = 1, 2, ..., n, then the 1 ( )
ϕ1 (x) = 1 − e−p1 x (13)
output of the network is stated as follows: p1
∑n
aj ( ) 1 ( )
m(ti ) = 1 − e−(1−α j )b j ti . (12) ϕ2 (x) = 1 − e−p2 x (14)
j=1
1−αj p2

Equation (12) is the mean value function of the fault 1 ( )

ϕ3 (x) = 1 − e−p3 x . (15)
generation based statistical parametric SRGM incorporating p3
the consideration of different (n) types of faults in the Using the activation functions (13), (14) and (15) for the
software. hidden layer neurons 1, 2 and 3 respectively and proceeding in
In the software reliability literature, flexible generalized the similar manner along with (8)–(11), the network output is
dynamic integrated model (FGDIM) [15], dynamic weighted derived as follows:
combinational model (DWCM) [13] and neural network
ensembles model (NNEM) [14] are three popular ANN based ∑
3
w2 j ( )
software reliability models. In these models, different types of y′i (ti ) = 1 − e−p j w1 j ti . (16)
j=1
pj
ANNs have been developed to predict the software reliability.
FGDIM considers learning phenomenon where a single layer The values of network weights w1 j , w2 j and the activation
feedforward ANN is proposed to predict the reliability of function parameter p j ( j = 1, 2, 3) are evaluated dynamically
software consisting of n types of faults. The number of through learning algorithm of the ANN depending on the
neurons in the hidden layer is same as the types of faults in the feature of the software failure data.
ROY et al.: FORECASTING OF SOFTWARE RELIABILITY USING NEIGHBORHOOD FUZZY PSO BASED NOVEL NEURAL NETWORK 1369

Replacing the( weights) w1 j by b j , w2 j by a j and the From (20), we see that there are three tuning parameters,
parameter p j by 1 − α j , j = 1, 2, 3 in (16), we get namely w , c1 and c2 in the PSO algorithm. The inertia weight
w [∈ (0, 1)] manages the exploration properties of the
∑3
aj ( ) algorithm. Parameter w is used to balance the global and local
m(ti ) = 1 − e−(1−α j )b j ti . (17)
j=1
1−αj search capabilities of the particles. During search process of
the standard PSO algorithm, w decreases linearly from 0.8 to
Equation (17) represents mean value function of the fault 0.4 . Generally, w is presented by the following equation:
generation based statistical parametric SRGM proposed by g
Lynch et al. [9] considering three types of faults in the w = wmax − (wmax − wmin ) (22)
gmax
software.
where wmax is the initial weight, wmin is the final weight and
B. Software Release Time Policy gmax is the maximum number of iterations. w is decreased
Software reliability, defined as the probability that there are from wmax to wmin. Learning factors c1 and c2 control the in-
no software failures in the time interval (t, t + ∆t) , is given as fluence of the cognitive and social components respectively.
follows: Cognitive component forms the memory of the particle con-
[ ( )] cerning its previous best known position whereas social com-
R(∆t|t) = exp − y′ (t + ∆t) − y′ (t) , ∆t > 0 (18)
ponent forms the memory of the particle regarding the best
where ∆t is the mission time of reliability and y′ (t) is pre- position among the particles in the swarm. Impact of pbesti
dicted cumulative number of detected software failures at test- and gbest are determined by c1 and c2 respectively. If c1 < c2 ,
ing time t. the particle i has a tendency to converge to the gbest rather
We designate a target reliability level and release the than the pbesti . According to previous experiments [17], [23],
software at the time point when that objective is attained. [38], a setting with c1 = c2 = 2 is used to implement the stand-
Then, the optimal release time problem which minimizes the ard PSO algorithm.
release time of the software subject to reliability greater than Standard PSO algorithm undergoes early convergence
or equal to a predefined reliability level can be formulated as problem while solving highly multimodal problems. In this
follows: section, we propose a neighborhood based fuzzy PSO
Minimize T s.t. R(∆t|T ) ≥ R0 (19) algorithm to present a trade-off between exploration (global
search capability) and exploitation (local search capability).
where T is the release time of the software and R0 is the aspir-
ation level of software reliability to be gained at the release A. Neighborhood Based Learning Strategy
time T. In this experiment, we consider R0 = 0.99 . Neighborhood of a particle, trapped in a sub-optimum, can
V. Proposed Neighborhood Based Fuzzy PSO Algorithm contain the global optimum. In this situation, searching the
neighborhood of the particle is very useful to locate global
PSO is a population based stochastic metaheuristic
optimal solution. Neighborhood search strategy is efficient to
optimization algorithm inspired by the group’s ability of some
solve multimodal problems when the sub-optimum is near to
animal species (such as bird flocking or fish schooling) to
the global optimum.
locate a desirable position in a specified area. A swarm
In this paper, we propose a neighborhood based learning
comprises a set of particles and each particle denotes a
strategy of the PSO algorithm which consider the local best
potential solution vector of the optimization problem. Position
particle in the neighborhood of a particle instead of the global
of each particle is updated dynamically depending on its
best particle in the velocity updating rule to avoid trapping in
preceding position and new velocity which is evaluated
local optima. Here, all the particles are a member of some
through learning from its own experience and other particles
neighborhood which is constructed by some topological
in the swarm. Current position and velocity vector of particle i
g g design and the learning of the particle is restricted to that
at iteration g are signified by Xi and Vi respectively. Personal
neighborhood only.
historical best known position, i.e., the best position found in
Here, for implementation of the neighborhood, we use ring
the search space so far for particle i is represented by pbesti .
topology for the sake of simplicity setting the length of the
Global best particle’s position is denoted by gbest . During
neighborhood to 5, because complex topologies increase the
searching, velocity and position vector of particle i are
runtime complexity of the algorithm. Two adjacent particles
updated by the following equations:
in both sides of a particle in the ring are identified to be
g+1 g
( g
) ( g
)
Vi = wVi + c1 r1 pbesti − Xi + c2 r2 gbest − Xi (20) neighbors of the particle. Fig. 3 presents a ring topology with
12 particles in the swarm. Let Pi (for i = 1, 2, ..., N ) is the ith
g+1
Xi
g
= Xi + Vi
g+1 particle in the swarm, where N is the swarm size. We consider
g+1
N + 1 ≡ 1 and N + 2 ≡ 2 , where N is the number of particles in
Xmin ≤ Xi ≤ Xmax , i = 1, 2, ..., N (21) the swarm. The N particles are arranged on a ring topology
where i is the index of particle, N is the swarm size, w is the according to their indices, such that PN and P2 are the two
inertia weight, c1 and c2 are acceleration coefficients, r1 and r2 immediate neighbors of P1. The k− neighborhood radius of
are random numbers between 0 and 1, Xmin and Xmax denote each particle Pi consists of particles Pi−k , ..., Pi , ..., Pi+k , where
lower and upper bounds of the search space respectively. k is an integer and 0 ≤ k ≤ N−12 . Experimental studies reveal
1370 IEEE/CAA JOURNAL OF AUTOMATICA SINICA, VOL. 6, NO. 6, NOVEMBER 2019

that the performance of the proposed PSO algorithm is not 0.4 ≤ w ≤ 0.8, 0.5 ≤ c1 ≤ 2.5, 0.5 ≤ c2 ≤ 2.5.
affected by the parameter k . Similar performance is achieved To fuzzify each input and output, the membership functions
for different values of k . In this paper, k is set to 2 to of d , w , c1 and c2 shown in Figs. 4–7 respectively are used.
implement the neighborhood of a particle. Fig. 3 shows the k−
neighborhood radius with k = 2 . If index of the particle is i, μ
then the neighborhood of the ith particle includes the particles
Small Medium Large
having indices i − 2, i − 1, i + 1 and i + 2 as shown in Fig. 3. 1

2-neighborhood of Pi Degree of
membership
Pi+2
PN 0 d
Pi+1 d1 d′

P1 Pi Fig. 4. Membership functions for d.

Pi−1
P2 μ
Pi−2 Small Medium Large
1

Fig. 3. Ring topology with 2-neighborhood radius. Degree of

membership
Let lbest is the local best particle’s position, i.e., the
0 c1
position of the best particle in the neighborhood of a particle. 0.5 1.0 1.5 2.0 2.5
Then (20) becomes as follows:
g+1 g
( g
) ( g
) Fig. 5. Membership functions for w.
Vi = wVi + c1 r1 pbesti − Xi + c2 r2 lbest − Xi . (23)
Now the particle i learns simultaneously from lbest and μ
pbest of itself. According to (23), each particle will shift Small Medium Large
1
towards its own best position as well as the best position of its
Degree of
neighborhood, instead of the global best position as in (20). membership

B. Adaptive Fuzzy Scheme

0 w
We consider fuzzy adaptive nature of the PSO parameters 0.4 0.5 0.6 0.7 0.8
such that it cannot be ensnared in local optima. Fuzzy
IF/THEN rules are applied to adaptively control the inertia Fig. 6. Membership functions for c1.
weight w and learning factors c1 and c2 in (23) of the PSO
algorithm to get better efficiency and searching accuracy. μ
Let f (gbestg ) represents the best fitness function value at Small Medium Large
iteration g and d denotes the difference between the f (gbest)’s 1
for two consecutive iterations. At iteration g, d is evaluated Degree of
membership
(for minimization problems) as follows:
( )
dg = f gbestg−1 − f (gbestg ) ≥ 0. (24) 0 c2
0.5 1.0 1.5 2.0 2.5
When d is large, particularly in the beginning of the
searching process, w and c1 should be increased to explore the Fig. 7. Membership functions for c2.
search space thoroughly to find global solution and c2 should
be reduced to lesser value to avoid an early termination of Here, Small, Medium and Large are the linguistic values
searching. As d is decreasing, the particles of the swarm are defined by fuzzy sets for the input and outputs. The following
converging to an optimal solution and the area around the best Mamdani-type fuzzy rules are proposed to formulate the
solution should be searched thoroughly. Hence, w and c1 are conditional statements that comprise fuzzy logic.
set to smaller values and c2 is increased to a larger value to Rule 1: IF d is Small,
improve the convergence speed. When d is medium, w , c1 and THEN w is Small, c1 is Small and c2 is Large.
c2 are kept at medium values. According to this knowledge, a Rule 2: IF d is Medium,
fuzzy system is proposed to tune the inertia weight and THEN w is Medium, c1 is Medium and c2 is
learning factors with d as the input variable, and w , c1 and c2 Medium.
as the output variables. Rule 3: IF d is Large,
The lower and upper bounds for w , c1 and c2 are taken as THEN w is Large, c1 is Large and c2 is Small.
follows: Every rule depicts a mapping from the input space to the
ROY et al.: FORECASTING OF SOFTWARE RELIABILITY USING NEIGHBORHOOD FUZZY PSO BASED NOVEL NEURAL NETWORK 1371

output space. To get a crisp value, the outputs must be data set. NRMS E value is minimized by the PSO algorithm
defuzzified. In this paper, defuzzification of every output is during training of the ANN. Here, the proposed PSO al-
accomplished by applying the centroid method. gorithm is applied for better learning of the proposed ANN to
Let the maximum number of iterations gmax is divided into predict more accurately the reliability of software.
q partitions, represented by qi, i = 0, 1, ..., q − 1 and partition qi The procedure involved in the proposed neighborhood
consists of ni iterations. Hence based fuzzy PSO algorithm to train the proposed ANN based
software reliability model (FPSONNM) is presented in
∑
q̄−1
gmax = ni . (25) Algorithm 1 as shown in next page:
i=0 The proposed algorithm for learning of FPSONNM using
After ni iterations of partition qi, the values of d′ and d1 in software failure data is implemented in MATLAB 2018a and
Fig. 4 are modified once. It is evident that after ni iterations, ni the source code of the algorithm and associated functions to
new d 's are generated by (24). The values of d′ and d1 are train the proposed ANN are given in Appendix.
updated as follows: VI. Software Failure Data Sets
{ { }
′ max ni new d′ s , if i = 0 Three real software failure data sets DS 1, DS 2 and DS 3 are
d = { } (26)
max previous d′ , ni new d′ s , if i > 0 employed in this experiment for validity and performance
analysis of the proposed FPSONNM. Interval domain data are
1 organized in pairs {ti , yi } where yi is the cumulative number of
d1 = d′ (27)
2 software failures detected at testing time ti and i is the
d′ and d1 are not available for the first n0 iterations. cumulative software execution time sequence index. The
Therefore, we assume the consequent part of fuzzy Rule 3 by description of the three interval domain data sets are given
selecting bigger constant for w and c1 (w = 0.8 and c1 = 2.5) below:
and smaller constant for c2 (c2 = 0.5). DS 1 : This data set is obtained from Misra [41] wherein the
number of faults observed for each week is indicated. 231
C. Implementation of Proposed PSO Algorithm for Learning
failures are detected during the complete execution time of 38
ANN Based Software Reliability Model
weeks.
Initially, the proposed ANN based software reliability DS 2 : This data set is reported by Musa [42] based on the
model (Fig. 2) is trained by the standard PSO algorithm. Then 136 failures observed during system testing for 25 hours of
we train the model using the proposed neighborhood based CPU time from a real-time command and control system with
fuzzy PSO algorithm to assess the reliability of software 21, 700 assembly instructions developed in Bell Laboratories.
containing three types of faults in fault generation DS 3 : This data set is acquired from Jet Propulsion
environment. Representation of the network weights and Laboratory project J1 [1]. Over the course of 62 weeks, 133
activation function parameters of the proposed ANN in a failures are detected.
particle is shown in Fig. 8. Before feeding to the ANN, ti and yi of each data set are
normalized in [0, 1].
w11 w12 w13 w21 w22 w23 p1 p2 p3 Laplace test is employed to identify the trend in failure data
[1]. Let the entire testing period, represented by the time
Input-hidden Hidden-output Activation function interval [0, T ] be separated into h equal units of time. The
layer weights layer weights parameters
Laplace factor for interval domain failure data is described as
Fig. 8. Structure of a particle. follows [1]:
∑
h
∑
h
The activation function parameters of the hidden layer (i − 1)n(i) − h−1 n(i)
2
neurons of the proposed ANN are combined with the weights i=1 i=1
of the ANN in a particle to be determined by the PSO l(h) = v
t (29)
h2 − 1 ∑
h
algorithm. Here, error function is the fitness function of the n(i)
PSO algorithm. In this paper, normalized root mean square 12 i=1
error (NRMS E ) produced by the ANN is used as error
where n(i) is the number of faults detected in time unit i. Pos-
function to be minimized as follows:
itive values of l(h) signify decreasing software reliability,
v
u
u
u
u
u ∑m ( )2 while negative values indicate increasing software reliability.
u
u
u
u
u y′i (ti ) − yi (ti ) If values of l(h) fluctuate between –2 and +2, they indicate
u
u
u
NRMS E = u u i=1 stable reliability. Analytical trend test results for DS 1, DS 2
t (28)
∑m and DS 3 are exposed in Fig. 9.
2
yi (ti ) From Fig. 9(a), it is observed that there are some valleys
i=1 under l(h) = −2 at around 0.2 , 0.3, 0.4 , 0.8 and 0.9 normalized
where m is the number of data points applied for learning of execution times. As for Fig. 9(c), we see that there are two
the ANN, yi (ti ) is actual value and y′i (ti ) is predicted value valleys under l(h) = −2 at around 0.05 and 0.4 normalized
produced by the ANN for the ith data point of software failure execution times. These indicate that some inflection points
1372 IEEE/CAA JOURNAL OF AUTOMATICA SINICA, VOL. 6, NO. 6, NOVEMBER 2019

exit in the data sets DS 1 and DS 3. Trends in failure data DS 1 23: Place the previous and the current f (gbest)’s into (24)
and DS 3 appear to be stable reliability between the value of to find a new d and store it
l(h) = +2 and l(h) = −2 with a reliability increase at some 24: end for
execution times where the value of l(h) is under −2 . Fig. 9(b) 25: Determine the value of d′ by utilizing n0 d 's in (26) and
shows stable reliability between the value of l(h) = +2 and then evaluate the value of d1 using (27)
l(h) = −2 followed by negative (below −2 ) Laplace factor at 26: for each partition qi, i = 1, 2, ..., q − 1 do
the end representing increasingly reliability growth in DS 2. It 27: for each of the ni iterations do
is found that the three data sets contain dissimilar reliability 28: for each particle i = 1, 2, ..., N do
patterns as indicated by the trend test results. Hence, it is 29: Determine the local best particle’s position lbest
difficult for software testing team to use a single statistical in the neighborhood of the particle i
parametric model which fits well into all these data sets. 30: Use the latest d in the fuzzy rules 1−3 and
defuzzify the outputs using centroid method to evaluate new
Algorithm 1 Proposed neighborhood based fuzzy PSO crisp values of w , c1 and c2
algorithm 31: Generate uniformly distributed random numbers
r1 and r2 in [0, 1]
Input: Software failure data set to train the proposed ANN
32: Update the velocity vector Vi by using the new w ,
Optimal: setting of the connection weights and activation
c1 and c2 in equation (23)
function parameters of the proposed ANN
33: Update the position vector Xi using the equation
1: Initialization: Initialize the dimension of the solution
(21) and check with its limits
vector dim = 9, lower and upper bounds of the search space:
34: if (fitness function value of Xi < fitness function
Xmin and Xmax respectively, swarm size N = 40 and maximum
value of pbesti ) then
number of iterations gmax = 104 . Initialize gbest randomly
35: Update the particle’s best known position as
within the search boundaries. pbesti = Xi
2: for each particle i = 1, 2, ..., N do
36: if (fitness function value of pbesti < fitness
3: Initialization: Initialize position and velocity vectors Xi
function value of gbest ) then
and Vi respectively within the search boundaries. Initialize the
37: Update the global best particle’s position as
particle’s best known position as its initial position, i.e., gbest = pbesti
pbesti = Xi
38: end if
4: if (fitness function value of pbesti < fitness function
39: end if
value of gbest ) then
40: end for
5: Update the global best particle's position as
gbest = pbesti 41: Calculate a new d by (24) and store it
42: end for
6: end if
43: Update the value of d′ by substituting the ni d 's and
7: end for
the latest d′ into (26) and then update the value of d1 using
8: Divide gmax into q partitions qi, i = 0, 1, ..., q − 1 assuming
(27)
that partition qi contains ni iterations
44: end for
9: for first n0 iterations in partition q0 do
45: Return gbest which contains the optimal solution, i.e.,
10: for each particle i = 1, 2, ..., N do
the optimal setting of the connection weights and activation
11: Determine the local best particle’s position lbest in
function parameters of the proposed ANN to predict software
the neighborhood of the particle i
reliability
12: Set w = 0.8, c1 = 2.5 and c2 = 0.5
13: Generate uniformly distributed random numbers r1
and r2 in [0, 1] VII. Model Performance Measures
14: Update the velocity vector Vi using the equation Performance comparison criteria are used to compare fitting
(23) performance and predictability of the FPSONNM and other
15: Update the position vector Xi using the equation ANN based software reliability models being considered.
(21) and check with its limits Here, we exploit the variable-term prediction and end-point
16: if (fitness function value of Xi < fitness function prediction approaches.
value of pbesti ) then
17: Update the particle’s best known position as A. Fitting Performance Measure
pbesti = Xi To determine fitting performance, initially the ANN based
18: if (fitness function value of pbesti < fitness software reliability model is trained using a fraction of the
function value of gbest ) then failure data (training data). Then, the trained ANN is used to
19: Update the global best particle's position as estimate the same failure data which was used to train the
gbest = pbesti ANN. The estimated cumulative failure number y′i at
20: end if execution time ti is compared with the actual cumulative
21: end if failure number yi from the data set. The fitting performance of
22: end for an ANN based software reliability model is evaluated by the
ROY et al.: FORECASTING OF SOFTWARE RELIABILITY USING NEIGHBORHOOD FUZZY PSO BASED NOVEL NEURAL NETWORK 1373

0 0
2.0
−1
−0.5 1.5
−2
1.0
−1.0 −3
0.5

Laplace factor
−4 0

Laplace factor
Laplace factor

−1.5 −5 −0.5
−6 −1.0
−2.0 −7 −1.5
−2.5 −8 −2.0
−9 −2.5
−3.0 −10 −3.0
0 0.2 0.4 0.6 0.8 1.0 0 0.2 0.4 0.6 0.8 1.0 0 0.2 0.4 0.6 0.8 1.0
Normalized execution time Normalized execution time Normalized execution time
(a) DS1 (b) DS2 (c) DS3

Fig. 9. Laplace trend test.

relative error (RE) and average error (AE) as follows: the time t x . More perfect prediction with more confidence in a
software reliability model can be attained as the RPE value
y′i − yi
REi = × 100 (30) approaches to zero.
yi To compare the accuracy of predictions, a boxplot is also
used to represent the distribution of RPEs of the different
1∑
n
AE = REi (31) models under comparison.
n i=1
VIII. Experimental Results
where n is the number of data points applied to train the ANN
The fitting and prediction performances of the FPSONNM
and to be estimated. Lesser value of AE represents lower fit-
are compared with the PSONNM and the other ANN based
ting error with better goodness of fit.
software reliability models such as FGDIM [15], DWCM [13]
B. Variable-Term Prediction and NNEM [14] in the software reliability literature. FGDIM,
To determine the variable-term predictability, a fraction of DWCM and NNEM are trained using back-propagation
the failure data is employed to train the ANN. Then, the learning algorithm.
trained ANN is used for prediction of the remaining failure A. Model Validation for DS1
data. The predicted cumulative failure number y′i at execution
Table I demonstrates the fitting performance of different
time ti is compared with actual cumulative failure number yi
software reliability models under comparison by means of AE
from real failure data set. The variable-term prediction ability
for different normalized execution time (NET) values of DS1.
of ANN based software reliability model is evaluated through
RE and AE as follows:
TABLE I
1∑ Comparison of Fitting Performance Results for DS1
m
AE = REi (32)
m i=1 NET FPSONNM PSONNM FGDIM DWCM NNEM
0.1 5.4289 6.5546 9.2286 15.0387 18.2075
where m is the number of data points to be predicted. Lower
0.2 4.7386 6.3364 7.7772 13.2523 16.7798
value of AE indicates better predictive validity.
0.3 3.4800 5.0917 7.0751 5.0227 11.6420
C. End-Point Prediction 0.4 4.0042 4.0048 5.6124 4.2324 10.6090
Let according to the real software failure data set, s x failures 0.5 4.5678 4.8752 5.6033 7.5670 8.4364
are detected at the end of the testing time t x . The end-point
0.6 4.0186 4.5345 4.7036 6.3314 5.4322
prediction is evaluated employing the available failure data
0.7 3.6222 3.9550 4.2414 5.7817 9.7772
upto time te (te ≤ t x) to predict the number of failures at the
execution time t x . We employ different sizes of training 0.8 3.7639 3.7677 4.0660 5.2110 8.2433
patterns for learning of the ANN. We apply t x as input to the 0.9 2.2261 3.5421 3.6310 3.4728 9.8280
trained ANN for prediction of the number of failures at the 1.0 1.6114 3.4139 3.8059 3.2140 7.8759
time t x . The predicted value is compared with the actual value
s x . The end-point prediction capability are evaluated by RE From Table I, we notice that the FPSONNM has smallest
for different values of te [42]. Lower value of RE indicates AE value among the models being considered for all NETs of
better end-point predictability. DS1. Hence, FPSONNM provides best fitting performance in
1) Relative Prediction Error: The relative prediction error
DS1.
(RPE) is determined as follows [42]:
Fig. 10 shows the fitting of the FPSONNM (which has the
y′x (t x ) − s x best fitting ability among the models under comparison)
RPE = (33)
sx relating to DS1 graphically using goodness of fit curve.
where y′x (t x ) is the predicted cumulative number of failures at From Fig. 10, we perceive that the FPSONNM has the
1374 IEEE/CAA JOURNAL OF AUTOMATICA SINICA, VOL. 6, NO. 6, NOVEMBER 2019

excellent fitting power relative to the realistic failure data of TABLE II

DS1. Comparison of Variable-Term Predictability for DS1
NET FPSONNM PSONNM FGDIM DWCM NNEM
1.0
0.1 20.7001 23.1563 23.8743 38.0355 35.9788
0.9
Normalized Cumulative number of failures

0.2 10.9428 18.7633 11.2929 19.2772 35.6264

0.8 0.3 3.2298 10.6746 7.1557 8.3118 28.9301
0.7 0.4 3.3850 6.6845 6.0987 7.3650 22.2076
0.6 0.5 3.2016 4.1289 6.3017 7.0752 7.7716
0.5 0.6 4.0249 4.4459 5.8685 4.7532 8.6871
0.4 0.7 2.2411 3.2968 4.2919 4.4550 5.7472
0.3 0.8 2.2778 2.2921 3.8633 4.0655 6.8934

0.2 0.9 1.9938 2.3604 2.6838 2.7754 5.3839

0.1 Actual value

Predicted value FPSONNM has the best predictive capability which proves
0
0 0.2 0.4 0.6 0.8 1.0 the outstanding ability of the proposed ANN based software
Normalized execution time reliability model trained by the proposed neighborhood based
FPSO algorithm in software reliability prediction.
Fig. 10. Goodness of fit curve of FPSONNM for DS1.
Table III demonstrates the end-point prediction through RE
After training of the proposed ANN using the neighborhood for different NET values that vary from 0.1 to 0.9.
based fuzzy PSO algorithm, the network weights and
activation function parameters are evaluated as follows: w11 = TABLE III
End-Point Prediction of Software Reliability for DS1
0.1000, w12 = 1.9721, w13 = 0.1000, w21 = 0.1000, w22 =
0.1031, w23 = 11.0750, p1 = 45.0000, p2 = 20.0880, p3 = NET FPSONNM PSONNM FGDIM DWCM NNEM
3.2033. 0.1 27.1313 40.9062 42.9996 54.8941 44.5924
Fig. 11 depicts the convergence characteristics of the 0.2 18.0704 21.4590 24.4834 47.9586 26.3276
proposed neighborhood based fuzzy PSO (FPSO) and 0.3 17.3733 20.9025 17.8022 17.8217 19.6891
standard PSO algorithms regarding learning of the proposed
0.4 4.6776 9.5424 11.7835 14.4947 18.8577
ANN based software reliability model employing the entire
0.5 4.9740 6.2392 6.0094 14.2953 14.9357
data points of DS1.
0.6 3.2687 3.4788 6.9264 12.5387 15.8628
0.8 0.7 3.2337 4.1775 4.7360 6.0483 12.5710
FPSO
PSO 0.8 0.8424 2.1437 2.2055 4.7010 12.5875
0.7
0.9 0.6945 1.6582 2.1002 2.4221 9.6054
0.6

0.5
From Table III, we observe that the FPSONNM has much
Fitness value

better end-point predictive power than the PSONNM,

0.4 FGDIM, DWCM and NNEM as the RE value of the
FPSONNM is least among the RE values of the models being
0.3
considered for all NETs of DS1.
0.2 Tables I–III establish the fact that as the proposed
neighborhood based FPSO algorithm is employed for learning
0.1 of the proposed ANN based software reliability model, it
0 0
provides superior fitting and predictive accuracy than the
10 101 102 103 104 model trained by the standard PSO algorithm.
Iterations
Fig. 12 shows the RPE curves and Fig. 13 displays the
Fig. 11. Convergence of learning algorithms for DS1.
boxplot of RPEs of the different ANN based software
reliability models under comparison for DS1.
From Fig. 11, it is obvious that the proposed neighborhood As seen from Figs. 12 and 13, the FPSONNM generally has
based FPSO algorithm converges efficiently during much lesser RPE value (very close to 0) and much lesser box
minimization of the error generated by the ANN. length and whisker range than the other models. These results
Table II shows the variable-term prediction by means of AE indicate the excellent software reliability predictability of the
for NET values that differ from 0.1 to 0.9. proposed model.
From Table II, it is observed that the AE values of the Table IV shows the optimal release times derived from
proposed FPSONNM are smallest among the AE values of the different models being considered using DS1.
models under comparison for all NETs of DS1. So As shown in Table IV, optimal release times at the
ROY et al.: FORECASTING OF SOFTWARE RELIABILITY USING NEIGHBORHOOD FUZZY PSO BASED NOVEL NEURAL NETWORK 1375

1.0 1.000
0.8
0.995
0.6
0.990
Relative prediction error

0.4

Software reliability
0.2 0.985
0
0.980
−0.2 T=39.9980
NINEM 0.975
−0.4
DWCM
−0.6 FGDIM 0.970 T=35.5334
−0.8 PSONNM
FPSONNM 0.965 Δt= 0.01
T=27.5874 Δt= 0.02
−1.0
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0 Δt= 0.03
0.960
Normalized execution time 20 25 30 35 40 45 50
Testing time (Weeks)
Fig. 12. RPE curves of software reliability models for DS1.
Fig. 14. Reliability growth curve for FPSONNM (DS1).

Outlier value B. Model Validation for DS 2

Table V shows the fitting performance of different software
1.0
reliability models under comparison by AE for various NET
values of DS2.
Relative prediction error

0.5
TABLE V
Comparison of Fitting Performance Results for DS 2
0
NET FPSONNM PSONNM FGDIM DWCM NNEM
0.1 4.1879 5.3641 7.8784 16.3418 5.4632
−0.5 0.2 2.7840 4.0507 7.2612 8.2608 5.0671
0.3 2.6823 3.1859 6.5355 5.7417 3.2828
−1.0 0.4 2.0469 3.0818 3.9283 5.1876 3.2604
NNEM DWCM FGDIM PSONNM FPSONNM 0.5 1.9006 3.7090 4.0366 3.4272 3.0251
Software reliability model
0.6 1.8754 3.2297 3.4841 4.9993 2.6462
Fig. 13. Boxplot of RPEs of different models for DS1. 0.7 1.6308 3.1132 2.9610 3.5645 3.1859
0.8 1.4427 2.6462 3.0126 3.1946 2.8225
TABLE IV 0.9 0.5159 0.6877 2.9201 3.0905 1.2764
Optimal Software Release Time (in Weeks) for Different 1.0 0.0231 0.0344 2.6893 2.7550 1.2948
Models (DS 1)
FPSONNM PSONNM FGDIM DWCM NNEM From Table V, we observe that all AE values of the
R(0.01|T ) ≥ 0.99 27.5874 28.5050 28.7911 32.4239 32.9899 FPSONNM are smallest among the AE values of the different
R(0.02|T ) ≥ 0.99 35.5334 35.9591 36.3160 37.4636 36.5817 models being considered. Hence, the proposed FPSONNM
R(0.03|T ) ≥ 0.99 39.9980 40.7486 42.8021 46.9864 40.8883 has the best fitting power in DS2.
Fig. 15 graphically illustrates the fitting of the FPSONNM
predefined level of software reliability are evaluated using the relating to DS2 by goodness of fit curve.
From Fig. 15, we find that the FPSONNM has good fitting
ANN based software reliability models. It is observable here
capability relative to the actual failure data from DS2.
that earliest release of software is possible if we apply the
The network weights and activation function parameters
proposed FPSONNM to predict the software reliability during
evaluated after learning of the proposed ANN using the
the testing period.
neighborhood based fuzzy PSO algorithm are as follows:
Fig. 14 graphically demonstrates the optimal release times w11 = 47.0000, w12 = 5.6268, w13 = 0.5000, w21 = 0.5000,
with different mission times based on the FPSONNM using w22 = 0.5000, w23 = 2.8423, p1 = 47.0000, p2 = 2.3841, p3 =
DS1. 2.5245.
From Fig. 14, the optimal software release times for Fig. 16 depicts the convergence characteristics of the
different time increments are estimated for FPSONNM based proposed neighborhood based FPSO and standard PSO
on achieving the desired level of software reliability. We algorithms regarding learning of the proposed ANN based
observe that earlier release is probable for smaller increase in software reliability model employing the entire data points of
time. DS2.
1376 IEEE/CAA JOURNAL OF AUTOMATICA SINICA, VOL. 6, NO. 6, NOVEMBER 2019

1.0 TABLE VI
0.9 Comparison of Variable-Term Predictability for DS 2
Normalized cumulative number of failures 0.8 NET FPSONNM PSONNM FGDIM DWCM NNEM

0.7 0.1 18.7934 19.1804 66.1393 35.9817 32.1490

0.2 6.0724 14.9094 50.5587 35.9419 19.6582
0.6
0.3 4.3286 5.0694 44.9785 22.0073 10.3662
0.5
0.4 4.7337 5.8907 25.5339 17.9080 15.4935
0.4
0.5 2.9964 5.8923 19.1604 13.2078 3.0597
0.3
0.6 1.6732 3.9751 11.4563 10.3553 2.9654
0.2
0.7 0.9618 1.1066 8.5039 4.7197 1.3162
0.1 Actual value
0.8 0.3764 0.5320 6.4182 3.0805 1.1586
Predicted value
0 0.9 0.3367 0.3466 5.7150 2.9146 0.8332
0 0.2 0.4 0.6 0.8 1.0
Normalized execution time

TABLE VII
Fig. 15. Goodness of fit curve of FPSONNM for DS2.
End-Point Prediction of Software Reliability for DS 2
NET FPSONNM PSONNM FGDIM DWCM NNEM
100
FPSO 0.1 22.8815 26.8070 58.5270 63.9828 44.5303
PSO
0.2 20.7753 24.5149 48.2228 31.8544 35.7211
0.3 6.2507 12.8920 18.1166 22.2922 10.6265
0.4 2.0113 11.1706 6.4855 24.5596 5.4251
Fitness value

0.5 1.7498 2.2029 9.2543 21.9796 3.8851

10−1 0.6 0.5755 1.4263 4.9936 11.8291 3.9352
0.7 0.4868 1.0976 4.8783 8.8958 2.9512
0.8 0.2065 0.2611 3.3798 4.5913 2.5525
0.9 0.0289 0.0636 1.7099 4.7405 1.8363

1.0
10−2
100 101 102 103 104 0.8
Iterations
0.6
Relative prediction error

Fig. 16. Convergence of learning algorithms for DS2. 0.4

0.2
It is apparent from Fig. 16 that the proposed neighborhood 0
based FPSO algorithm converges efficiently during
−0.2
minimization of the error generated from the ANN in learning
−0.4 NNEM
by the data points of DS2. DWCM
−0.6
Table VI shows the variable-term prediction by AE for FGDIM
different NET values of DS2. −0.8 PSONNM
FPSCONNM
Table VI demonstrates that the proposed FPSONNM has −1.0
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0
the best software reliability forecasting capability due to its Normalized execution time
minimum AE values relative to the PSONNM and other ANN
based software reliability models being considered. Fig. 17. RPE curves of software reliability models for DS2.
Table VII illustrates the end-point predictability through RE
for various NET values of DS2. whisker range than the other models. These results again
From Table VII, we find that all RE values of the indicate the excellent software reliability predictability of the
FPSONNM are least among the RE values of the models proposed FPSONNM.
under comparison. Hence, it is evident that the FPSONNM Table VIII demonstrates the optimal software release times
has best end-point predictive performance than the other derived from different models being considered for DS2.
models. From Table VIII, the optimal release times at the predefined
Fig. 17 shows the RPE curves and Fig. 18 displays the level of software reliability are evaluated using the different
boxplot of RPEs of the software reliability models being ANN based software reliability models. It is also observed
considered for DS2. here that the earliest release time is possible by applying the
From Figs. 17 and 18, we observe that the FPSONNM has proposed FPSONNM to predict the software reliability during
the smallest RPE value and the smallest box length and testing.
ROY et al.: FORECASTING OF SOFTWARE RELIABILITY USING NEIGHBORHOOD FUZZY PSO BASED NOVEL NEURAL NETWORK 1377

0.4 Outlier value TABLE IX

Comparison of Fitting Performance Results for DS3
0.3
NET FPSONNM PSONNM FGDIM DWCM NNEM
0.2
Relative prediction error

0.1 25.4520 32.9923 52.9710 47.7386 40.3513

0.1 0.2 24.1338 30.9146 45.8797 46.4401 34.1478

0
0.3 19.2071 22.0355 39.8253 40.7632 32.3452
0.4 16.0355 23.2055 29.1422 36.2731 30.0934
−0.1
0.5 15.2781 25.8823 29.0403 37.7353 29.0608
−0.2 0.6 15.2440 24.2258 20.3291 31.7492 25.1118

−0.3 0.7 13.5358 17.9075 15.5751 22.6165 22.7045

0.8 10.6317 14.3717 16.1756 21.1781 21.2649
−0.4
0.9 9.4657 14.5601 18.8040 17.5741 18.9394
NNEM DWCM FGDIM PSONNM FPSONNM
Software reliability model 1.0 8.8076 12.6199 14.5590 13.4681 14.6377

Fig. 18. Boxplot of RPEs of different models for DS2. AE values of the FPSONNM are smallest among the AE
values of the different models being considered. Hence, the
TABLE VIII FPSONNM has the best fitting power in DS3 also.
Optimal Software Release Time (in Hours) for Different Fig. 20 graphically depicts the fitting of FPSONNM relating
Models (DS 2)
to DS3 by goodness of fit curve.
FPSONNM PSONNM FGDIM DWCM NNEM
R(0.01|T ) ≥ 0.99 20.2380 22.1855 21.6064 21.1682 21.8196 1.0

Normalized cumulative number of failures

R(0.02|T ) ≥ 0.99 25.2731 25.3097 25.8574 26.1773 26.4044 0.9
R(0.03|T ) ≥ 0.99 28.8456 30.2890 34.5088 29.3918 30.3499 0.8
0.7
Fig. 19 graphically illustrates the optimal release times with
0.6
different mission times based on the FPSONNM using DS2.
0.5
1.000 0.4

0.995 0.3
0.2
0.990
0.1 Actual value
Sofware reliability

0.985 Predicted value

0
0 0.2 0.4 0.6 0.8 1.0
0.980 T=28.8456 Normalized execution time

0.975 Fig. 20. Goodness of fit curve of FPSONNM for DS3.

T=25.2731
0.970
From Fig. 20, we conclude that the FPSONNM has good
0.965 T=20.2380 Δt= 0.01 fitting capability relative to the experimental failure data of
Δt= 0.02
Δt= 0.03 DS3.
0.960 After learning of the proposed ANN using the neighborhood
10 15 20 25 30 35 40
Testing time (hours) based fuzzy PSO algorithm, the connection weights and
activation function parameters on the network are evaluated as
Fig. 19. Reliability growth curve for FPSONNM (DS2). follows: w11 = 0.3000, w12 = 0.3000, w13 = 0.3000, w21 =
0.3000, w22 = 0.3000, w23 = 3.5570, p1 = 56.0000, p2 =
From Fig. 19, the optimal software release times for 56.0000, p3 = 0.3000.
different time increments are estimated for the FPSONNM Fig. 21 shows the convergence characteristics of the
based on achieving the desired level of software reliability. proposed neighborhood based FPSO and standard PSO
Earlier release is promising for smaller time increase. algorithms regarding learning of the proposed ANN based
software reliability model employing the entire data points of
C. Model Validation for DS 3
DS 3.
Table IX shows the fitting performance of various software From Fig. 21, it is obvious that the proposed neighborhood
reliability models through AE for different NET values of based FPSO algorithm converges efficiently during
DS3. minimization of the error generated from the ANN in learning
From Table IX, it is observed that the FPSONNM has better by the data points of DS3.
fitting accuracy than the other compared models in DS3 as all Table X shows the variable-term predictability by AE for
1378 IEEE/CAA JOURNAL OF AUTOMATICA SINICA, VOL. 6, NO. 6, NOVEMBER 2019

101 TABLE XI
FPSO End-Point Prediction of Software Reliability for DS3
PSO
NET FPSONNM PSONNM FGDIM DWCM NNEM
0.1 22.5462 46.1762 52.8263 88.7471 53.0016
100 0.2 16.3454 18.3553 32.7447 81.9082 17.3322
Fitness value

0.3 8.4376 9.2656 15.0674 74.8851 14.9931

0.4 6.8896 8.7253 13.9251 46.7114 13.5224
0.5 5.4079 6.0851 8.3945 30.3983 14.0854
10−1
0.6 2.2134 3.1523 11.1688 24.0166 10.9280
0.7 2.0029 2.4935 5.8471 13.8667 9.9761
0.8 0.8320 1.4878 2.5689 5.8330 5.8030
10−2 0 0.9 0.1769 0.3019 0.7296 0.9724 3.1997
10 101 102 103 104
Iterations

1.0
Fig. 21. Convergence of learning algorithms for DS3.
0.8
0.6
TABLE X

Relative prediction error

Comparison of Variable-Term Predictability for DS3 0.4

NET FPSONNM PSONNM FGDIM DWCM NNEM 0.2

0.1 36.2980 37.9409 53.5693 73.0126 54.0826 0

0.2 14.4289 16.0850 39.0555 45.2522 25.7800 −0.2

0.3 7.3485 13.4703 23.3145 36.7324 27.8627 −0.4 NNEM

−0.6 DWCM
0.4 7.4508 9.2037 13.8400 32.3915 14.9551
FGDIM
0.5 5.7362 8.0172 13.3959 21.3051 12.6778 −0.8 PSONNM
FPSONNM
0.6 3.5443 3.6203 8.2325 13.2449 7.3943 −1.0
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0
0.7 4.1667 4.2897 4.8230 9.0306 10.3507 Normalized execution time
0.8 2.4571 4.1655 3.8416 9.0240 9.2307
Fig. 22. RPE curves of software reliability models for DS3.
0.9 2.1247 2.4863 2.5938 3.5884 3.1641

different NET values of DS3. 1.2 Outlier value

From Table X, it is obvious that the FPSONNM has best 1.0
software reliability predictive power due to its lowest AE 0.8
values at all NETs of DS3 relative to the other software
Relative prediction error

0.6
reliability models being considered.
Table XI shows the end-point predictability through RE for 0.4

different NET values of DS3. 0.2

From Table XI, we observe that the proposed FPSONNM 0
has best end-point prediction capability as all RE values of the −0.2
FPSONNM are smallest among the RE values of the −0.4
compared models.
−0.6
Fig. 22 shows the RPE curves and Fig. 23 displays the
boxplot of RPEs of the different software reliability models −0.8
NNEM DWCM FGDIM PSONNM FPSONNM
for DS3. Software reliability model
From Figs. 22 and 23, it is observed that the FPSONNM
generally has lower RPE and smaller box length and whisker Fig. 23. Boxplot of RPEs of different models for DS3.
range than the other compared models. Moreover, we find that
the FPSONNM and PSONNM have no outlier value in other ANN based software reliability models.
Fig. 23. Hence, the proposed FPSONNM has good software Table XII shows the optimal software release times derived
reliability predictability in DS3. from different models being considered for DS3.
From these experiments, we recognize that the proposed From Table XII, the optimal release times at the predefined
neighborhood based FPSO algorithm has superior ANN level of software reliability are determined using the different
learning capability than the standard PSO algorithm and the ANN based software reliability models. The earliest release
proposed FPSONNM has better fitting performance and time is also possible by applying the proposed FPSONNM
predict software reliability more perfectly than PSONNM and during testing period to predict the reliability of software.
ROY et al.: FORECASTING OF SOFTWARE RELIABILITY USING NEIGHBORHOOD FUZZY PSO BASED NOVEL NEURAL NETWORK 1379

TABLE XII release times based on obtaining a target level of software

Optimal Software Release Time (in Weeks) for Different reliability with different time increments are evaluated using
Models (DS3)
the different software reliability models under consideration.
FPSONNM PSONNM FGDIM DWCM NNEM
Experimental results demonstrate that the neighborhood
R(0.01|T ) ≥ 0.99 38.9033 40.4635 42.5113 44.0597 49.2773 fuzzy particle swarm optimization based proposed neural
R(0.02|T ) ≥ 0.99 54.5873 55.5167 57.8599 57.6646 54.9414 network model has considerably lower fitting and prediction
R(0.03|T ) ≥ 0.99 69.7381 70.0800 70.6570 71.8267 70.1747 error compared to the standard particle swarm optimization
based proposed neural network model and other neural
Fig. 24 graphically illustrates the optimal release times with network based software reliability models. Hence, it is very
different mission times based on the FPSONNM using DS3. useful of exploiting the proposed neighborhood based fuzzy
particle swarm optimization algorithm to train the proposed
1.000
neural network based software reliability model as proposed
0.995 particle swarm optimization based neural network has greater
fitting and predictive power than other compared models.
0.990
From the comparative study, we can conclude that the
Sofware reliability

0.985 proposed particle swarm optimization algorithm has better

neural network learning capability than the stan dard particle
0.980 swarm optimization algorithm and the proposed particle
T=69.7381
0.975 swarm optimization based neural network model has better
T=54.5873 fitting performance and predict software reliability more
0.970 precisely than the standard particle swarm optimization based
T=38.9033 Δt= 0.01 proposed neural network model and other neural network
0.965
Δt= 0.02 based software reliability models. Proposed framework is
Δt= 0.03
0.960 most promising for the purpose of software reliability
20 30 40 50 60 70 80 90 100
Testing time (Weeks) prediction. We can release the software quickly if we apply
the proposed particle swarm optimization based neural
Fig. 24. Reliability growth curve for FPSONNM (DS3). network model for prediction of software reliability during the
testing period. Earlier release of software is feasible for
From Fig. 24, the optimal software release times for
smaller increase in mission time but cost-benefit analysis
different time increments are estimated for the FPSONNM
based on achieving the desired level of software reliability. should be performed to decide whether to carry out more
We find that earlier release is achievable for smaller increase testing or release the software earlier. We believe that the
in time. proposed model can be employed at the time of software
testing for effective managing of software quality through the
IX. Conclusion accurate forecasting of reliability. The neighborhood fuzzy
In this paper, an artificial neural network based software particle swarm optimization based proposed neural network
reliability model is proposed to get better predictive accuracy can be an optimistic model which may be supportable for
of the reliability of software. The proposed neural network is software industry and may allow software engineers to make
developed considering the effect of fault generation with suitable decisions based on software requirements during the
different levels of fault complexity. We demonstrate the development phase.
proposed model for software containing three types of faults, Different types of neural network architectures can be
namely simple, hard and complex faults. We further propose a constructed by altering the number of hidden layer neurons
neighborhood based fuzzy particle swarm optimization and changing the activation function and bias in the neurons
algorithm for learning of the proposed neural network using for software reliability prediction considering the various
the real software failure data. The experiments are performed events that occur during software testing. In addition to
based on three real software failure data sets. To validate the reliability, software development cost should also be taken
effectiveness of the proposed model, we compare the fitting into consideration to estimate the optimal software release
and prediction performances of the neighborhood fuzzy time. Other variants of particle swarm optimization algorithm
particle swarm optimization based proposed neural network should be applied to train the proposed neural network based
model with the standard particle swarm optimization based software reliability model based on software failure data sets.
proposed neural network model and three existing neural Various evolutionary computation techniques except particle
network based software reliability models from the literature. swarm optimization can also be employed for superior and
The performance of the proposed neighborhood based fuzzy quicker learning of the proposed neural network for estimation
particle swarm optimization algorithm is also compared with and prediction of software reliability. Furthermore, fuzzy
the standard particle swarm optimization algorithm through neural network can be developed allowing uncertainty in
learning of the proposed neural network. The optimal software software reliability prediction.
1380 IEEE/CAA JOURNAL OF AUTOMATICA SINICA, VOL. 6, NO. 6, NOVEMBER 2019

Appendix v_max = (b(j)–a(j))/2;

Source code for proposed neighborhood based fuzzy PSO v(i,j) = –v_max+2*rand*v_max;
algorithm end
if (fpsonnm(p(i,:))<fpsonnm(gbest))
A. f psonnm f itting.m gbest = p(i,:);
clc; end
clear; end
global n; for itn = 1:1000
load x pgbest = gbest;
load t for i = 1:sm_sz
n = 37; lbest = x(i,:);
w = fapso(40); for j = i–2:i+2
in = zeros; if (i~ = j)
out = zeros; if (j< = 0)
p = zeros; k = j+sm_sz;
y = zeros; end
avge = 0; if (j>sm_sz)
for j = 1:3 k = j–sm_sz;
p(j) = w(j+6); end
end if (j>0 && j< = sm_sz)
for i = 1:n k = j;
for j = 1:3 end
in(j) = x(i)*w(j); if (fpsonnm(x(k,:))
end <fpsonnm(lbest))
for j = 1:3 lbest = x(k,:);
out(j)=(1/p(j)) end
*(1–exp(–p(j)*in(j))); end
end end
on_in = out*w(4:6)'; w = 0.8;
on_out = on_in; c1 = 2.5;
y(i) = on_out; c2 = 0.5;
avge = avge+abs((y(i)–t(i))/t(i)); for j = 1:d
end r1 = rand;
ae = (1/n)*avge*100; r2 = rand;
disp('AE'); v(i,j) = w*v(i,j)
disp (ae); +r1*c1*(p(i,j)–x(i,j))
+r2*c2*(lbest(j)–x(i,j));
B. f apso.m end
function z = fapso(sm_sz) x(i,:) = x(i,:)+v(i,:);
load FAPT; for j = 1:d
d = 9; if (x(i,j)<a(j))
a = [0 0 0 0 0 0 0 0 0]; x(i,j) = a(j);
b = [50 50 50 50 50 50 50 50 50]; end
x = zeros; if (x(i,j)>b(j))
p = zeros; x(i,j) = b(j);
v = zeros; end
gbest = zeros; end
fit_val1 = zeros; if (fpsonnm(x(i,:))
fit_val2 = zeros; <fpsonnm(p(i,:)))
fit_val = zeros; p(i,:) = x(i,:);
df = zeros; if (fpsonnm(p(i,:))
for j = 1:d <fpsonnm(gbest))
gbest(j) = a(j)+rand*(b(j)–a(j)); gbest = p(i,:);
end end
for i = 1:sm_sz end
for j = 1:d end
x(i,j) = a(j)+rand*(b(j)–a(j)); df(itn) = fpsonnm(pgbest)–fpsonnm(gbest);
p(i,j) = x(i,j); fit_val1(itn) = fpsonnm(gbest);
ROY et al.: FORECASTING OF SOFTWARE RELIABILITY USING NEIGHBORHOOD FUZZY PSO BASED NOVEL NEURAL NETWORK 1381

end end
df1 = df(itn); end
d1 = max(df); df(itn) = fpsonnm(pgbest)
dm = 0.5*d1; –fpsonnm(gbest);
m1 = 0; df1 = df(itn);
for m = 1:9 itn1 = itn+m1*1000;
df = zeros; fit_val2(itn1) = fpsonnm(gbest);
FAPT.input.mf(1).params = [–4.8 0 dm]; end
FAPT.input.mf(2).params = [0 dm d1]; d11 = max(d1,df);
FAPT.input.mf(3).params = [dm d1 999]; d1 = max(d11);
for itn = 1:1000 dm = 0.5*d1;
pgbest = gbest; m1 = m1+1;
for i = 1:sm_sz end
lbest = x(i,:); fit_val = [fit_val1 fit_val2];
for j = i–2:i+2 z = gbest;
if (i~ = j)
C. f psonnm.m
if (j< = 0)
k = j+sm_sz; function z = fpsonnm(w)
end global n;
if (j>sm_sz) load x
k = j–sm_sz; load t
end in = zeros;
if (j>0 && j< = sm_sz) out = zeros;
k = j; p = zeros;
end y = zeros;
if (fpsonnm(x(k,:)) a = 0;
<fpsonnm(lbest)) b = 0;
lbest = x(k,:); for j = 1:3
end p(j) = w(j+6);
end end
end for i = 1:n
pm = evalfis(df1,FAPT); for j = 1:3
w = pm(1); in(j) = x(i)*w(j);
c1 = pm(2); end
c2 = pm(3); for j = 1:3
for j = 1:d out(j) = (1/p(j))*
r1 = rand; (1–exp(–p(j)*in(j)));
r2 = rand; end
v(i,j) = w*v(i,j) on_in = out*w(4:6)';
+r1*c1*(p(i,j)–x(i,j)) on_out = on_in;
y(i) = on_out;
+r2*c2*(lbest(j)–x(i,j));
a = a+(t(i)–y(i))^2;
end
b = b+(t(i)^2);
x(i,:) = x(i,:)+v(i,:);
end
for j = 1:d
e = sqrt(a/b);
if (x(i,j)<a(j))
z = e;
x(i,j) = a(j);
end
if (x(i,j)>b(j)) References
x(i,j) = b(j); [1] M. R. Lyu, Handbook of Software Reliability Engineering, New York,
end McGraw-Hill, 1996.
end
if(fpsonnm(x(i,:)) [2] M. Jain and R. Gupta, “Optimal release policy of module-based
<fpsonnm(p(i,:))) software,” Quality Technology and Quantitative Management, vol. 8,
p(i,:) = x(i,:); no. 2, pp. 147–165, 2011.
if (fpsonnm(p(i,:)) [3] A. L. Goel and K. Okumoto, “Time-dependent error-detection rate
<fpsonnm(gbest)) model for software reliability and other performance measures,” IEEE
gbest = p(i,:); Trans. Reliability, vol. 28, no. 3, pp. 206–211, 1979.
end
1382 IEEE/CAA JOURNAL OF AUTOMATICA SINICA, VOL. 6, NO. 6, NOVEMBER 2019

[4] M. Xie, “Software Reliability Modeling,” World Scientific, Singapore, vol. 8, no. 1, pp. 324–336, 2008.
1991.
[20] M. Nasir, S. Das, D. Maity, S. Sengupta, U. Halder, and P. N.
[5] H. Pham, System Software Reliability, New Jersey, Springer, 2006. Suganthan, “A dynamic neighborhood learning based particle swarm
optimizer for global numerical optimizatio,” Information Sciences,
[6] S. Yamada and S. Osaki, “Software reliability growth modeling: models vol. 209, pp. 16–36, 2012.
and applications,” IEEE Trans. Software Engineering, vol. 11,
pp. 1431–1437, 1985. [21] H. Wang, H. Sun, C. Li, S. Rahnamayan, and J. S. Pan, “Diversity
enhanced particle swarm optimization with neighborhood search,”
[7] J. Yang, Y. Liu, M. Xie, and M. Zhao, “Modeling and analysis of Information Sciences, vol. 223, pp. 119–135, 2013.
reliability of multi-release open source software incorporating both fault
detection and correction processes,” J. Systems and Software, vol. 115, [22] G. Xu, “An adaptive parameter tuning of particle swarm optimization
pp. 102–110, 2016. algorithm,” Applied Mathematics and Computation, vol. 219,
pp. 4560–4569, 2013.
[8] M. Ohba and X.M. Chou, Does imperfect debugging effect software
reliability growth, in Proc. 11th Int. Conf. on Software Engineering, [23] T. Niknam, “A new fuzzy adaptive hybrid particle swarm optimization
1989, pp. 237–244. algorithm for non-linear, non-smooth and non-convex economic
dispatch problem,” Applied Energy, vol. 87, pp. 327–339, 2010.
[9] T. Lynch, H. Pham, and W. Kuo, “Modeling software-reliability with
multiple failure-types and imperfect debugging, ” in Proc. Annual [24] Y. T. Juang, S. L. Tung, and H. C. Chiu, “Adaptive fuzzy particle
Reliability and Maintainability Symposium, 1994, pp. 235–240. swarm optimization for global optimization of multimodal functions,”
Information Sciences, vol. 181, pp. 4539–4549, 2011.
[10] Q. Li and H. Pham, “NHPP software reliability model considering the
uncertainty of operating environments with imperfect debugging and [25] E. Naderi, H. Narimani, M. Fathi, and M. R. Narimani, “A novel fuzzy
testing coverage,” Applied Mathematical Modelling, vol. 51, pp. 68–85, adaptive configuration of particle swarm optimization to solve
2017. largescale optimal reactive power dispatch,” Applied Soft Computing,
vol. 53, pp. 441–456, 2017.
[11] B. Pachauri, A. Kumar, and J. Dhar, “Modeling optimal release policy
under fuzzy paradigm in imperfect debugging environment,” [26] J. R. Zhang, J. Zhang, T. M. Lok, and M. R. Lyu, “A hybrid particle
Information and Software Technology, vol. 55, no. 11, pp. 1974–1980, swarm optimization-backpropagation algorithm for feedforward neural
2013. network training,” Applied Mathematics and Computation, vol. 185,
no. 2, pp. 1026–1037, 2007.
[12] S. M. Li, Q. Yin, P. Guo, and M. R. Lyu, “A hierarchical mixture model
for software reliability prediction,” Applied Mathematics and [27] S. Haykin, Neural Networks and Learning Machines, New
Computation, vol. 185, pp. 1120–1130, 2007. York, Prentice Hall, 2012.

[13] Y. S. Su and C. Y. Huang, “Neural-network-based approaches for [28] N. Karunanithi, D. Whitley, and Y. K. Malaiya, “Prediction of software
software reliability estimation using dynamic weighted combinational reliability using connectionist models,” IEEE Trans. Software
models,” J. Systems and Software, vol. 80, pp. 606–615, 2007. Engineering, vol. 18, pp. 563–574, 1992.

[14] J. Zheng, “Predicting software reliability with neural network [29] K. Y. Cai, L. Cai, W. D. Wang, Z. Y. Yu, and D. Zhang, “On the neural
ensembles,” Expert Systems with Applications, vol. 36, pp. 2116–2122, network approach in software reliability modeling,” J. Systems and
2009. Software, vol. 58, pp. 47–62, 2001.

[15] P. K. Kapur, S. K. Khatri, and M. Basirzadeh, “Software reliability [30] S. L. Ho, M. Xie, and T. N. Goh, “A study of the connectionist models
assessment using artificial neural network based flexible model for software reliability prediction,” Computers and Mathematics with
incorporating faults of different complexity, International Journal of Applications, vol. 46, pp. 1037–1045, 2003.
Reliability,” Quality and Safety Engineering, vol. 15, no. 2, pp. 113–127,
[31] L. Tian and A. Noore, “On-line prediction of software reliability using
2008.
an evolutionary connectionist model,” J. Systems and Software, vol. 77,
[16] C. J. Hsu and C. Y. Huang, “Optimal weighted combinational models pp. 173–180, 2005.
for software reliability estimation and analysis,” IEEE Trans.
[32] Q. P. Hu, M. Xie, S. H. Ng, and G. Levitin, “Robust recurrent neural
Reliability, vol. 63, no. 3, pp. 731–749, 2014.
network modeling for software fault detection and correction
[17] J. Kennedy and R. C. Eberhart, “Particle swarm optimization,” in Proc. prediction,” Reliability Engineering and System Safety, vol. 92,
IEEE Int. Conf. Neural Networks, 1995, pp. 1942–1948. pp. 332–340, 2007.

[18] K. E. Parsopoulos and M. N. Vrahatis, “Particle swarm optimization [33] N. R. Kiran and V. Ravi, “Software reliability prediction by soft
and intelligence: advances and applications,” Information Science computing techniques,” J. Systems and Software, vol. 81, no. 4,
Reference, 2010.
pp. 576–583, 2008.
[19] M. S. Arumugam and M. V. C. Ra, “On the improved performances of
the particle swarm optimization algorithms with adaptive parameters, [34] P. K. Kapur, V. S. S. Yadavalli, S. K. Khatri, and M. Basirzadeh,
crossover operators and root mean square (RMS) variants for computing “Enhancing software reliability of a complex software system
optimal control of a class of hybrid systems,” Applied Soft Computing, architecture using artificial neural-networks ensemble,” Int. J.
ROY et al.: FORECASTING OF SOFTWARE RELIABILITY USING NEIGHBORHOOD FUZZY PSO BASED NOVEL NEURAL NETWORK 1383

Reliability Quality and Safety Engineering, vol. 18, no. 3, pp. 271–284, Pratik Roy (S’15) received the M.Sc. degree in
computer science from Vidyasagar University, India.
2011. He have worked as a direct Senior Research Fellow
of CSIR, India and submitted his Ph.D. thesis in
[35] R. Mohanty, V. Ravi, and M. R. Patra, “Hybrid intelligent systems for computer science at University of Calcutta, India. He
predicting software reliability,” Applied Soft Computing, vol. 13, no. 1, has eight years research experience. He has pub-
pp. 189–200, 2013. lished several research papers in international journ-
als like Applied Soft Computing, Expert Systems with
[36] O. F. Arar and K. Ayan, “Software defect prediction using cost- Applications, International Journal of Reliability,
sensitive neural network,” Applied Soft Computing, vol. 33, Quality and Safety Engineering, etc. His research in-
pp. 263–277, 2015. terests include genetic algorithm, particle swarm optimization, fuzzy set the-
ory, artificial neural network, hardware and software reliability. Presently, he
is working on software reliability assessment under soft computing environ-
[37] P. Roy, G. S. Mahapatra, and K. N. Dey, “An efficient particle swarm ment.
optimization-based neural network approach for software reliability
assessment,” Int. J. Reliability, Quality and Safety Engineering, vol. 24, Ghanshaym Singha Mahapatra holds the degrees
no. 4, pp. 1–24, 2017. of M.Sc. and Ph.D. in applied mathematics from In-
dian Institute of Engineering Science And Techno-
[38] Y. Shi and R. C. Eberhart, “A modified particle swarm optimizer,” in logy, Shibpur, India. He is an Associate Professor in
the Department of Mathematics in National Institute
Proc. IEEE World Congr. on Computational Intelligence, 1998, pp. of Technology, Puducherry, Karaikal-609609, India.
69–73. He has been involved in teaching and research for
more than 13 years. He has published many research
[39] Y. Marinakis, A. Migdalas, and A. Sifaleras, “A hybrid particle swarm papers in various international and national journals
including Applied Mathematics and Computation,
optimization – variable neighborhood search algorithm for constrained Journal of Fuzzy Mathematics, Fuzzy Information and Engineering, Interna-
shortest path problems,” European J. Operational Research, vol. 261, tional Journal of Fuzzy Systems, Advances in Fuzzy Sets and Systems, Journ-
al of Optimization Theory and Applications, Applied Soft Computing, Nonlin-
pp. 819–834, 2017. ear Dynamics, etc. Several students are at present working for Ph.D. under his
supervision. His fields of research work are inventory management, reliabil-
[40] C. Jin and S. W. Jin, “Parameter optimization of software reliability ity optimization, fuzzy set theory, fuzzy mathematical programming, mathem-
growth model with S-shaped testing-effort function using improved atical biology and soft computing.
swarm intelligent optimization,” Applied Soft Computing, vol. 40,
pp. 283–291, 2016. Kashi Nath Dey is presently an Associate Professor
of the Department of Computer Science and Engin-
eering, University of Calcutta, India. He had an in-
[41] P. N. Misra, “Softawre reliability analysis,” IBM Systems J., vol. 22,
dustry experience of about eight years. Regarding
pp. 262–270, 1983. publications, he published around 25 papers in differ-
ent international journals and conferences together
[42] J. D. Musa, A. Iannino, and K. Okumoto, Software Reliability with three text books from Pearson Education
(India).
Measurement, Prediction and Application, New York, McGraw-Hill,
1987.