A Non-Homogeneous Poisson Process Software Reliability Growth Model with Imperfect Debugging via Hybrid Neural Network–Crow Optimization Parameter Estimation

The COA is a metaheuristic based on population that is aimed at solving nonlinear optimization problems. In comparison to the early swarm-based algorithms, including Particle Swarm Optimization (PSO) and Genetic Algorithm (GA), COA adds to the search space a memory mechanism that improves exploratory and exploitative search. Every candidate solution is indicated as a parameter space vector. At iteration $t$, the position of the $i^{\text {th}}$ solution is denoted as $\boldsymbol{x}_i^t \in \mathbb{R}^d$, where $d$ is the number of parameters to be optimized. Each solution retains a memory $\boldsymbol{m}_i^t$, which corresponds to its historically best position [31]. The update rule is defined as:

$\boldsymbol{x}_i^{t+1}= \begin{cases}\boldsymbol{x}_i^t+r \cdot f_l \cdot\left(\boldsymbol{m}_j^t-\boldsymbol{x}_i^t\right), & \text { if } r \geq A P_j, \\ \text { random position in search space, } & \text { otherwise, }\end{cases}$

where, $r \sim U(0,1)$ is a random number, $f_l>0$ is the flight length parameter controlling step size, $A P_j \in[0,1]$ is the awareness probability of solution $j, \boldsymbol{m}_j^t$ is the best-known solution of a randomly chosen peer $j$. Algorithm 1 shown below outlines the main procedure of the COA, and its Pseudocode represent the initializes a population of crows, assigns memory to each solution, and iteratively updates positions based on a random peer selection and awareness probability.

NHPP gives a well-established method for software failure process modeling. A generalized NHPP formulation, which clearly considers imperfect debugging, error introduction, and error reduction, was taken. The reliability function is modeled in the form of a cumulative intensity function, and the failure MVF is the center of the parameter estimation. To enhance the readability, the key modeling assumptions are discussed in separate subsections [34].

Assumption 1: Error reduction

Error correction efficiency generally declines as the number of errors detected increases because of interdependence, human factors, and organizational limitations. This is modeled by the exponential reduction error factor. The errors that are corrected at time t are:

$m(t)=m_0 \exp (-\beta t)$              (1)

where, $m_0$ is the initial correction rate and $\beta$ is the reduction coefficient.

Assumption 2: Error introduction during debugging

Correction of faults can also cause new errors, especially in complicated systems. This is modeled as a rate of error generation that depends on the current activity of debugging:

$\frac{d x(t)}{d t}=\gamma m(t)$             (2)

where, $\gamma$ is the error introduction coefficient.

Assumption 3: Per-error fault identification rate

The probability of finding a certain fault reduces with time as the remaining faults are more difficult to find. This is modelled as a decaying rate of detection exponentially:

$a(t)=a_0 \exp (-\delta t)$             (3)

where, $a_0$ is the initial detection rate and $\delta$ is the decay constant.

The generalized NHPP-based SRGM, which is a combination of these assumptions, is subjected to the system of differential Eqs. (5)-(10). To make them readable, the main text of the resulting MVF is given:

$M(t)=f(a(t), x(t), m(t))$          (4)

4.1 Utilizing a new method to analyze software reliability growth models

In the NHPP framework, the derivation of the traditional failure MVF is based on four key assumptions: Failure model assumptions are (a) each failure indicates a single fault; (b) the failure rate is constant in terms of faults; (c) if a failure is identified then the corresponding fault is repaired and deselected; (d) the rate of failure identification increases along with the number of unidentified faults in the software with a constant of proportionality. Additionally, the generalized imperfect debugging NHPP model incorporates three more assumptions: Some of these are: (i) The proportion of failure detection, above mentioned, is postulated as depending on time, $\tau$, i.e., $k(\tau)$; (ii) By correction of read errors, other errors may be produced in the process or is dependent of time t. Other assumptions made in the context of this research include the following: (iii) Error correction is noisy, that is, every error that has been found up to the time $\tau$ is corrected probabilistically. The generalized NHPP model for imperfect debugging, which incorporates the efficiency of error removal, is formulated as follows [18]:

$m^{\prime}(\tau)=k(\tau)[a(\tau)-Q m(\tau)]$             (5)

where, Q is the measurement of the likelihood of error correction, while $(t)$ is the number of errors that have been corrected by the time $(t)$. For generalization, the newly proposed SRGM is developed starting from the differential equation below:

$m^{\prime}(\tau)=k(\tau)[a(\tau)-x(\tau)]$           (6)

In particular, it is acknowledged that the actual count of corrected errors $(t)$, depends directly on the error reduction coefficient [20]. Using the basis given in Eq. (6), we develop an improved model that involves additional assumptions.

4.1.1 Mathematical derivation of the proposed Non-Homogeneous Poisson Process model

In order to enhance the interpretability of the proposed SRGM, the detailed description in this section follows the step-by-step mathematical formulation, finally arriving at the desired MVF. Where $m(t)$ refers to the MVF, which is the average count or number of software faults that will be detected up to time t. Within the context of an NHPP, the fault detection rate is the derivative of the MVF:

$\lambda(t)=\frac{d m(t)}{d t}$              (7)

where, $\lambda(t)$ represents the failure intensity function, describing how quickly faults are detected during testing. The productivity of error correcting in the practical debugging processes declines with an increase in the number of faults found. The model of this effect is an exponential error reduction factor:

$\eta(t)=\eta_0 e^{-\alpha m(t)}$               (8)

where, $\eta_0$ represents the initial correction efficiency, and $\alpha$ denotes the reduction coefficient controlling how rapidly the correction efficiency declines.

This formulation reflects the increasing complexity of remaining faults as testing progresses. Under realistic debugging conditions, it is possible that fixing a identified fault will create new errors. Let gamma represent the coefficient of error introduction, which is the percentage of error induced in the process of modification activities. This is because both the fault elimination and the fault creation processes affect the net change in the number of residual faults. The other useful learning in software testing is that as time goes by, the likelihood of the software identifiers finding the remaining faults also reduces. This is the case because simpler faults are normally identified at an earlier period, and then later faults are harder to detect. The detection rate per fault can thus be represented as an exponential type of function:

$\beta(t)=\beta_0 e^{-\delta t}$           (9)

where, $\beta_0$ is the initial detection rate, and $\delta$ represents the decay constant of detection efficiency.

Combining the above mechanisms, the rate of fault detection in the system depends on three factors:

• the remaining number of faults,

• the efficiency of debugging, and

• the time-dependent detection capability.

Thus, the generalized NHPP differential equation describing the failure process can be expressed as:

$\frac{d m(t)}{d t}=\beta(t)(a-m(t)) \eta(t)$           (10)

where, $a$ represents the number of inherent faults in the software system. The replacement of the expressions of $\beta(t)$ and $\eta(t)$ into the equation leads to a nonlinear differential model of fault detection, correction, and introduction dynamics. The solution of this equation, under the first condition.

4.1.2 Three important assumptions

(i) Modeling assumptions for exponential error reduction

In this framework, the error reduction factor serves as a governing parameter that constrains the differential formulation of the cumulative number of observed failures t and correctable errors t. In other words, the effectiveness of the following error correction steps may reduce with the number of discovered errors in the actual debugging processes. This assumption is premised on three sources that stem from a reduction in interdependencies among errors, the mental inertia associated with focusing on the current task, and the instability within the debugging team. First, modifying errors may be influenced in such a manner; for instance, a particular error may be associated with certain other removed errors to reduce the information regarding the rest of the sections that are available for modification in due course. Second, the currently induced mental set may interfere with the ability of the corrector to consider other relations between the errors. Such occurrences lead to the notion that other related mistakes are not noticed by the corrector and hence cannot be changed using the modified mistake. Last but not least, the average level of correction and relevant experience of the correctors may deteriorate owing to some unpredictable circumstances, for example, transfers and replacements. In many software companies nowadays, skilled testers or correctors can be transferred or dismissed, as engineering needs appear. When successors are not engaged in programming, their inexperience can hinder the efficiency of correcting errors in the early stages of change. As such, instability in the debugging team can greatly reduce its efficiency in correcting errors.

Since the effectiveness of error correction may decrease with the increase of the number of identified errors, the error reduction factor may be defined as the constrained relationship between the number of detected errors and the error reduction factor, which is modeled as a decreasing exponential function of $(\tau)$. This formulation is derived from the defined characteristics of the error reduction factor. And the number of modified errors $(\tau)$ can be mathematically represented as [20]:

$\frac{x^{\prime}(\tau)}{m^{\prime}(\tau)}=q e^{-\beta m(\tau)}$            (11)

where, $q$ denotes the first value of this parameter, which is the first error reduction factor, describing the ratio of the initial rate of error correction to the initial rate of error detection, while $\beta$ is the reduction coefficient that defines the declining curve of the rate. Thus, the expression of error reduction stated in Eq. (7) is quite stable.

(ii) Rate of error introduction

Here, the aim is to develop a constrained regression model between the total error count and the parameters that guide it (t) and the modified error count (t) which will be used to find the dependency of the detected error count (t). Turning to the problem of new error incorporation, one should figure out that new errors occur not during the error detection stage but during the process of modifying existing ones. In general, it has been discovered that no matter how successful modification attempts are during the debugging process, the probability of creating new errors rises simultaneously with the number of attempts. On some occasions, it may require multiple debugging to complete fix this problem, which increases this risk. Because the occurrence of new errors coincides with the continuous modification of errors, it is reasonable to express the change rate of residual errors through a dynamic process covering both the generation of new errors and the modification process of errors. The differential relationship between the total number of errors (at) and the modified number of errors (xt) can be expressed as follows:

 $\frac{a^{\prime}(\tau)}{[a(\tau)-x(\tau)]^{\prime}}=-p$           (12)

Eq. (8) indicates that as the intensity of generalized modification increases, the likelihood of the error input rate also rises.

(iii) Per-error fault identification rate

In the current part, we are supposing that the detection of errors is possible in every fault and is a linearly fading exponential output of t. Notably, the detection rate by no means is assumed to be equal among all remaining faults of the software. With such an assumption in place, we assume that the background defects are discovered at the same discovery rate at any particular moment in time. However, as it is known, the detection efficiency per fault also tends to decrease with time. Several factors can be attributed to this fadeaway behavior, and they are mentioned below:

1. This is illustrated in section 1, where most of the studies pointed out that the so-called 'learning' process does not normally happen in real-life industrial and testing scenarios, due to a lack of resources and non-operational skills.

2. Since there are only a finite number of detection conditions and methods, and since there is often very little testing experience, it becomes increasingly difficult to uncover latent errors resident in large, complicated programs or abstract data types as time passes.

3. There is potential for degradation in the effectiveness of fault detection because of the large amount of work required for recording, testing, and analyzing program behavior, which can ultimately reduce the reliability of testers. To enhance the flexibility of our model, it is assumed that the per-error fault detection rate decreases exponentially with time $\tau$ and can be modeled as follows:

$k(\tau)=b e^{-(a+\alpha \tau)}$            (13)

where, b is the initial value of fault detection rate per error, and α defines the decay factor.

4.1.3 Practical validity of the modeling assumptions

To further support the assumptions underlying the proposed NHPP modeling, it is worthwhile to align them with empirical findings from real-world software testing environments. First, the assumption of error reduction reflects a practical phenomenon: debugging efficiency declines over time. Easily identified faults are eliminated early in testing, while those that remain become more complex and intertwined as testing progresses. Extensive empirical research on industrial software development projects has documented a decline in fault removal efficiency as testing matures, especially in large systems where code dependencies make fault fixing more challenging. Second, the introduction of errors during debugging is a well-documented phenomenon in software engineering practice. Because developers modify existing code to fix identified faults, changes can inadvertently create new defects when the developer does not fully understand how the systems interact or when sufficient regression testing is not performed. Large-scale software maintenance experiments have shown that corrective maintenance tends to introduce between 5–20 percent more faults, depending on system complexity and the developer's experience. Thus, representing the debugging process as a dynamic system that balances error removal with error introduction can better capture the evolution of software. Third, the assumption of a time-dependent fault detection rate aligns with the observation that fault detection efficiency follows a downward trend. In real-world testing, the most apparent errors are identified early, while the remaining errors are often more subtle and more difficult to trace. This pattern has been observed in numerous empirical datasets, including the Tandem Computers failure dataset and IEEE reliability benchmark datasets, where the fault discovery rate steadily decreases with testing. The validity of these assumptions is further supported by the simulation experiments and case studies presented in this work, such as the Tandem Computer Company dataset and the IEEE Std 1633 dataset. These realistic assumptions indicate that the proposed NHPP model fits better and has greater forecasting power under these conditions, confirming that the modeling framework captures key features of real-world software reliability growth.

4.2 An innovative software reliability growth model and its failure mean value function

4.2.1 An advanced software reliability growth model

Given the above-noted assumptions, the sustainable human resource management (SHRM) model, adapted as an SRGM, has been formulated as follows:

$\left\{\begin{array}{c}m^{\prime}(\tau)=k(\tau)[a(\tau)-x(\tau)] \\ \frac{x^{\prime}(\tau)}{m^{\prime}(\tau)}=q e^{-\beta m(\tau)} \\ \frac{a^{\prime}(\tau)}{[a(\tau)-x(\tau)]^{\prime}}=-p \\ k(\tau)=b e^{-(a+\alpha \tau)}\end{array}\right.$         (14)

Through solving Eq. (14) simultaneously under some initial conditions, one can obtain the corresponding solution, namely the MVF $m(t)$. In this case, to articulate the explicit failure MVF, the following theorem is presented:

Remark 1: Assuming that the MVF of failure, the dynamics of fault detection and removal, and the rate of error introduction assume the functional relationships as given in Eq. (10), and under the initial conditions $m(0)=0, x(0)=0$, and $b(0)=b_0$, the following form of the MVF of failure is obtained:

$m(t)=\frac{1}{\gamma} \ln \left[\frac{\left.\gamma b_0 e^{\left[\gamma b_0-q(1-p) * \frac{b}{\alpha} e^{-a}\left[1-e^{-\alpha t}\right]\right.}\right]_{-q(1-p)}}{\gamma b_0-q(1-p)}\right]$         (15)

Eq. (15) defines the full mean value, which incorporates nonlinear fault detection, correction, and introduction of behaviors during testing.

4.2.2 Further analysis of failure mechanisms in the mean value function

The section gets more into the dynamics of failure that is governed by MVF and provides major theoretical derivations to back the properties of the structural model.

• In Eq. (15), once the time t goes to infinity, then m(t) will converge to an upper bound, i.e.,

$\lim _{t \rightarrow \infty} m(t)=\frac{1}{\gamma} \ln \left[\frac{\left.\gamma b_0 e^{\left[\gamma b_0-q(1-p) * \frac{b}{\alpha} e^{-a}\left[1-e^{-\alpha t}\right]\right.}\right]_{-q(1-p)}}{\gamma b_0-q(1-p)}\right]$             (16)

The asymptotic fault bound is expressed in Eq. (16), demonstrating that there is a convergence to maximum reliability.

• Under the assumed initial conditions $m(0)=0$ and $x(0)=0$, an identity $x(t)=\frac{q}{\gamma}\left[1-e^{-\gamma m(t)}\right]$ follows directly from the differentiation of Eq. (10). (ii) Inserting Eq. (15) into the corresponding formulation leads to the expression for the number of corrected errors, presented in Eq. (17).

$x(t)=\frac{q}{\beta}\left[1-\frac{\gamma b_0-q(1-p)}{\gamma b_0 e^{\left[\gamma b_0-q(1-p) * \frac{b}{a} e^{-a}\right]_{-q(1-p)}}}\right]$         (17)

• Under the initial condition $b(0)=b_0$ substituting Eq. (17) into Eq. (14), the total error number is presented:

$\begin{gathered}b(t)=b_0+p x(t) =a_0+\frac{p q}{\gamma}\left[1-\frac{\gamma b_0-q(1-p)}{\gamma b_0 e^{\left[\gamma b_0-q(1-p) * \frac{b}{a} e^{-a}\right]_{-q(1-p)}}}\right]\end{gathered}$            (18)

Eqs. (17) and (18) explain how the corrected error and the total error change with time and explain why there is a tradeoff between detection and new-fault creation.

• If $\alpha \rightarrow 0$ (Implication of this is that fault detection rate per error is almost fixed. It is therefore possible to rewrite Eq. (15) as given below:

$m(t)=\frac{1}{\gamma} \ln \left[\frac{\left.\gamma b_0 e^{\left[\gamma b_0-q(1-p) * \frac{b}{\alpha} e^{-a}\left[1-e^{-\alpha t}\right]\right.}\right]_{-q(1-p)}}{\gamma b_0-q(1-p)}\right]$          (19)

• In Eq. (19), if $p \rightarrow 0$ (That shows that the error creation rate is in effect inexistent. In turn, Eq. (20) could be rewritten in the following way:

$m(t)=\frac{1}{\gamma} \ln \left[\frac{\gamma b_0 e^{\left[\gamma b_0-q * b e^{-a} t\right]}-q}{\gamma b_0-q}\right]$            (20)

Under the conditions of $b \rightarrow 0$ and $p \rightarrow 0$, the limit $\beta a_0 \rightarrow q$ is satisfied based on Eq. (14). In Eq. (20), if $b \rightarrow 1, \gamma b_0 \rightarrow q$, a general expression can be obtained:

$m(t)=\frac{1}{\gamma} \ln \left[1+\gamma b_0 e^{-a} t\right]$            (21)

Eqs. (19)-(21) give simplified or limiting cases of the equations based on particular conditions of operation (detect rate is constant, fault introduction is negligible or the conditions are symmetric) and provide useful approximations to several testing conditions.

Simulation is one of the study approaches that is used to study exact or hypothetical systems or processes by mimicking their behaviors through a model. As an adaptive system, it allows researchers to analyse the performance of one or many factors within a system and simulate experimental conditions without actually testing them. Real-world testing can often be impractical if not impossible, cost-prohibitive, or take too long to complete. Based on the analysis of various parameters and performing several experiments, simulation provides an understanding of system behaviors, confirmation of theory and model assumptions, as well as improvement of decision-making in numerous fields of engineering, economics, and software systems.

Table 3. Simulated RMSE comparison of the proposed model versus existing SRGMs when a = b = 0.5, α = β = 0.6, and p = q = 0.7

After determining the initial values for the parameters, these values were systematically adjusted in relation to the sample size and evaluated across multiple program iterations. Sample sizes of n = 20, 50, and 100 were analyzed, along with various combinations of parameter values, including (a = b = 0.5; α = β = 0.6 and N = c = 0.7). The results summarized in Table 3 show that the proposed model consistently achieves lower RMSE values compared to alternative models.

Even though the suggested NHPP-based SRGM has a high predictive performance and a better-fitting accuracy than a number of benchmark SRGMs, certain limitations must be recognized.

To start with, the proposed hybrid estimation framework is based on the configuration of FFANN, the choice of network architecture, the learning rate, and training parameters. These values are the ones that are set empirically by conducting experimental tests, and in other cases, various data sets or software systems may have to be fine-tuned to give the best results. As a result, the parameter estimation process could be sensitive to the network structure and training startup.

Second, the algorithm is not as practical in global search or parameter discovery because it is associated with extra computational expense, namely, its population-based iterative mechanism is known as CO. The computational complexity of the algorithm can become very large when the number of parameters or the size of the dataset is larger. Future experiments can focus on more effective hybrid optimization schemes or evolutionary metaheuristic algorithms to decrease computational time.

Third, even though the proposed model has been tested with benchmark datasets like the Tandem Computer Company dataset and the IEEE Std 1633 dataset, the datasets are controlled testing conditions. Further empirical confirmation of the large-scale industrial software systems would provide further empirical support to the generalizability as well as practical applicability of the model.

The current framework can be further elucidated in future studies in a number of ways. An option is to pursue the path of deep learning structures or recurrent neural networks to learn temporal relationships in software failure data. The other good direction is the creation of uncertainty-aware reliability models, which include the use of confidence intervals or Bayesian estimation for the uncertainty in parameters. Furthermore, the transfer learning methods could be applicable to enhance the model generalization, in case only sparse failure data are present. These extensions would additionally advance the strength, expansiveness, and sensible usefulness of NHPP-based reliability increase modeling in current software development systems.

The authors are very grateful to Duhok Polytechnic University for providing access, which allows for more accurate data collection and improves the quality of this work.