Appraising Early Reliability of a Software Component Using Fuzzy Inference

Abstract

(1) Objectives: Reliability is one of the major aspects for enhancing the operability, reusability, maintainability, and quality of a system. A software component is an independent entity that deploys to form a functional system (CBSS). The component becomes unreliable mainly because of errors introduced during its design and development; it is essential to estimate the reliability of a software component in advance. This research work proposes a novel Mamdani Fuzzy-Inference (M-FIS) model to estimate the components’ reliability and provides an intuitive solution for industry personnel; (2) Scope: The technology moves forward from traditional monolithic software development to scalable, integrated, business-driving software applications. Henceforth, the proposed paradigm can give a preliminary estimate of the reliability of software components, and it helps developers and vendors to produce it at high-quality; (3) Methods: In the component development and realization phase, failure data is unavailable; hence, designing metrics, inspections, statistical methods, soft-computing techniques are used to predict early reliability. The present work applies soft computing techniques to validate metrics. Moreover, estimating premature reliability reduces follow-up effort and component-development cost and time; (4) Finding: The proposed model aids the project manager in better estimating and predicting a components’ reliability. Adopting both an expert-based fuzzy inference system and an unsupervised, or self-learning, algorithm provides the basis for cross checking, and concludes with a better decision in an ambivalence state.

1. Introduction

Nowadays, IT and business trends need rapid application development, and to achieve this requires component-based development (CBD). Component-based development comprises congregation of modular, reusable, and self-contained components, which are glued together with a well-defined approach that allows the required plug-and-play functionality. Moreover, component assemblage reduces development time and cost. Developing such applications demands trusted components with high reliability. Reliability is an essential and quantifiable parameter of software quality. IEEE defines reliability as “the ability of a system or component to perform its required functions under stated conditions for a specified period of time” [1]. Hence, reliability is the measure of the likelihood that an application or components can meet continuous desired functionality in a specific environment over a given time period. The ideal goal of reliability is to achieve surety that the system or component will manage and control all functions and resources, and that they perform flawlessly. Systems such as aircraft, missiles, airplanes, shuttles, rockets, and life-saving bio-medical equipment deploy trusted components and are expected to possess high reliability. Thus, developers are likely to face challenges in realizing defect and failure-free components.

Like traditional software, in the component-development phase, reliability has some input in each stage of software development, including requirements analysis, designing, and coding [2], and can be improved through inspections, walkthroughs, and reviews. Analysis of legacy-software reliability predicts and estimates the software reliability using failure-data obtained during testing [3,4]. However, in component-based development, both developers and users need to compute the reliability. User-oriented component reliability is used for specific application projects, while the focus of this paper is to optimize the reliability at the vendors’ (COTS) and developers’ end. Furthermore, component-based systems demand highly reliable components needing less or no maintenance. Thus, in comparison to monolithic software, components must be rigorously built to achieve high reliability. There is a need for peer-reviewed measures for the enhancement of the component development process. Further, predicting premature reliability can help the component-designer to trace, analyze, and improve issues of weak design. Such prediction also reduces the rework effort and development cost for component production.

As per the existing literature, many researchers have not mentioned or discussed this knowledge for component-based development. Whereas, few researchers believe that the reliability used by vendors and developers is correct, and on this basis, they have estimated the reliability of component based systems [5,6,7,8]. This leads to vendors’ and developers’ fidelity in producing ideal components that can largely meet users’ requirement. Further, it is essential to assure the quality of various components. This article proposes the novel Mamdani fuzzy-inference system to estimate the premature reliability of components that help the developers and vendors to develop a high-quality software component. Mamdani fuzzy-inference systems are intuitive and human suitable. The proposal for the novel model is to obtain optimal output from a Mamdani fuzzy-inference system by applying two different mechanisms, i.e.: expert-domain knowledge, and self-learning or unsupervised learning. The emerging trends of industry seek cognitive approaches in automation, learning, and artificial intelligence. The major objective of this proposed model is to help the project manager or quality-control personnel to analyze and find a solution to ambiguity, and sort unreliable components before the next phase of development.

1.1. Software Component

Clemens Szyperski defines a software component as “a unit of composition with contractually specified interfaces and explicit context dependencies only. A software component can be deployed independently and is subject to the composition by third parties” [9].

The evolution of software-development architecture traces from traditional legacy software to component-based development, and the most sophisticated one is service-oriented architecture (SOA). SOA is composed of modern components which have more complex interaction protocols. SAO also inherits the architectures of component-based development and provides services to legacy systems. Further, component-based software engineering and service-oriented architecture swing software development from coding software systems to composing software systems.

A component is a compositional atom which encapsulates implementation and specifies a set of interfaces. The components can be independently deliverable, replaceable, and can be composed by a third party. Software components are categorized into three types: reusable modules, reusable components, and composite building blocks (as depicted in Figure 1).

• Reusable module: This is the traditional reusable concept, in which independent and realizable modules of the software encapsulate the functionality.
• Reusable component: This is an autonomous, exchangeable, deployable, and customized unit of software with specified interfaces. The third party can thereby reuse it according to application specifications and requirements.
• Composite building block: This emphasizes both component reuse and component composition to form a building block.

Probabilistically, one can estimate the reliability of a component using Equation (1).

$$P\left(R_{com}\right)=1-P\left(F_{com}\right)$$

(1)

However, reliability of the underlying component will vary based depending on the fixed period of time and specified environment, where $P\left(R_{com}\right)$ is the reliability of a component and $P\left(F_{com}\right)$ is the probability of a components’ failure. The failure of the component is directly proportional to errors, defects, or faults which impact the reliability of the component.

1.2. Research Flow

The investigation was conducted as follows.

• Understand the existing software industry model and investigate any acceptable real-time changes that can enhance the performance of the model.
• Identify the influencing real-time factors and design the metric, or better recognize the prevailing industry-based metric, as it is showing results in real-time application.
• Determine the best technique for experimenting (i.e., Mamdani-Fuzzy inference system). Mamdani FIS depends on experts’ opinions. It is highly natural and produces good results.
• Experts’ based M-FIS: Design the rules by taking opinions from experts and domain-knowledge engineers. Fuzzify the inputs, i.e. map crisp input(s) into a fuzzy variable. Defuzzify the output by mapping the output to a crisp value.
• In the absence of experts, and given the industry’s profound demand for maximum automation, seek for some learning algorithm which can design a Mamdani FIS through data sets. (Fuzzy C-mean sunsupervised or self-learning.)
• Generate an inference system using Fuzzy C-means clustering, providing an input/output data set. Rules are auto generated through analysis of data behavior. The model is self-trained and predicts the reliability [10].
• Estimate the obtained results for both fuzzy inference systems and compare with the original to find the percentage of error.

The rest of this paper is categorized into sections. Section two highlights the related work. Section three presents the fuzzy inference system and its mechanisms. Section four introduces the proposed model for estimating premature reliability. Section five describes the experiment conducted. Section six details the insightful results and discussion. Finally, section seven concludes the present research.

2. Related Work

This section discusses the existing research, which encourages us to study software components, their development models, optimization and quality, and reliability.

Wang et al. [7] proposed an architectural approach, using the reliability of each component and its operational profile, to estimate the reliability of a heterogeneous system. The approach transforms architecture into a state view, allowing computation of the reliability and transition-probability of each state. However, this approach also requires that the reliability of components be available. Gokhale et al. [6] presented a hierarchical model to predict software reliability, based on its architectural behavior using the Markov chain. The model determines systems performance, predicts reliability, and analyzes sensitivity, via component-reliability and component-time spent in each visit. Moreover, both component reliability and time spent in every visit are known beforehand, which implies that the model is dependent on the reliability provided by vendors or developers. Yacoub et al. [8] predicts the reliability of component-based systems as the function of an individual component and its interfaces. Furthermore, based on scenario-component execution, probabilities are drawn through sequence diagrams using CDG. However, this approach also depends on the reliability provided by third parties. Tyagi et al. [11] presented a soft computing model to estimate component-based system (CBSS) reliability using fuzzy logic, based on four real-time factors: reusability, component dependency, application complexity, and operational profile. However, the model does not account for the failure of components, and considers the reliability provided by vendors and developers to be correct. In this section, we are discussing a few approaches that mark some significance in our work.

Christenson et al. [12] used preparation effort and inspection rate for efficient- and marginal-inspection sessions. They used inspection data to predict defect density in the remaining line of codes, which helps a project manager to analyze the quality and reliability of components. Sun Sup So et al. [13] applied a fuzzy-logic approach to predict error- prone components and empirically validated the approach using published data. This work is the precursor of our proposed model. However, manual evaluation lacks precision and accuracy, and is time-consuming. Seliya et al. [14] proposed a novel method for software quality analysis, based on a semi-supervised clustering scheme that uses K-means as a clustering algorithm, which iteratively labels clusters as fault-prone. However, there are various modules which remain unlabeled.

Table 1. Comparative Study of Existing Literature.

Model	Basis Type	Operational Scope	Mechanism	Validation	Advantage	Disadvantage
[15]	Prediction/Black-box	Legacy Software Systems	Statistics and probability distribution	Real-time experimental validation	Explains failure phenomena in different environments	Programmer’s quality and difficulty is tougher to analyze
[16]	State-based Architectural/White-box	COTS, Component-based systems	Probability theory, matrix, mathematics	Validated by Illustrative Examples	The operational quality of a system can be predicted.	Real-time implementation is missing
[17]	Path Based Architectural Model, White-box	COTS, Component-based systems	Mathematical derivations, degree of independence, algorithms	Experimental validation	Considers component dependency, sensitivity, operational profile, interface, scalability and sets a basis for future works	Determining the value of degree of independence (DOI) is not clear.
[18]	State-based Architectural/White-box	SOA, Component-based system, COTS	State transition, probability, statistics, mathematical approach	Real-time validation (e-commerce) both empirically and experimentally	It indicates those program modules which are rare in use during execution time and are more critical one.	For reliability prediction, it needs partial statistical usage profiles.
[19]	Path-based Architectural/White-box	COTS, Component-based systems	CDG, Probability theory	Two case study and empirical validation	They are suited for component and system reliability estimation	Algorithm is not considered as overall reliability
[20]	Path-based Architecture/White-box	Component-based complex system, SOA	Mathematical equations	Not validated	Scope of Markov model is extended for complicated relationships of components	Assumes reliability and transition probability are known.
[21]	Path-based Architectural/ White-box	COTS, Component-based systems	Enhanced composition of algorithm, CDG, probability	Case study and Scenarios	Considering transition matrix and component to get the best result	No real time validation
[11]	Architectural model/White-box	COTS, Component-based system	Fuzzy inference system.	Empirical and Experimental validation	Software simulation is simple and accurate.	Model does not consider the probability of component failure
[22]	State-based architectural model/ White-box	COTS, Component-based system	DTMC, mathematical calculation, probability distribution theory.	Validated through two experimental studies.	Also analyzes the sensitivity of components, application reliability, and correlation parameters.	Analytical expression for application reliability is not computed
[23]	Path-based Architecture/White-box	Component-based complex system, COTS	Universal Live Sequence Charts (uLSC), Mathematical Formulas	Validated on automated railcar system	It accounts computational costs and scalability issue	Synchronization of execution among scenarios is not considered
[24]	No specific listing	Component based Software Engineering	Automated Component based Software Engineering	Predicted properties and extra functional characteristics	Automate the process of component deployment	Structural changes have a large impact
[25]	Black Box	Component based Software Engineering (CBSE) Approach, Commercial off the Shelf (COTS)	Research questionnaire in the field of CBSE	Surveys and Reports	Increase Productivity, save cost and improve quality	Detailed analysis on specific topic
[26]	No specific listing	Data Driven Software Engineering	Introducing framework for data engineering	Software Processes	Continuous software Engineering Process	Validity dependent on context and responsibility

presents a comparative study of existing literature.

3. Fuzzy Logic

Fuzzy logic is a computing approach to deal with ambiguity, uncertainty, and imprecision, and to provide the solution by degree of truthworthiness rather than bivalent logic, i.e. true and false. Fuzzy logic uses natural expressions (linguistic variables) to formulate mapping between inputs and outputs in the universe of discourse [27,28].

Fuzzy logic was introduced in 1965 by Lotfi A. Zadeh [29]. Since then it has been found to be the most precise prediction approach based on if-then rules. The various advantages are listed below.

• Rules designed with domain knowledge and experts’ opinion yield significantly better result compared to statistical and regression models.
• When there is less or no domain knowledge, rules can also be designed using clustering techniques such as Fuzzy C-means, K-means, subtractive clustering, etc.
• This approach can apply without historical data, or even no data.

3.1. Fuzzy Inference System (FIS)

A fuzzy inference system is a system designed to map input(s) and output(s) via fuzzy logic, using some logical operations and base rules. Thereby, it forms some basis for conclusions or pattern recognition. The system comprises four different sections:

• Fuzzification: Input possessing a crisp scalar value in the universe of discourse is not deterministic and carries uncertainty and doubts. Therefore, crisp inputs transform into a fuzzy singleton with the help of different types of fuzzifiers (membership functions) in a domain.
• Rule Base: Experts and knowledge engineers design and develop the rules for inference. However:
• Inference: The inference evaluates rules using fuzzy sets of operations, and thus combine to achieve the final result.
• Defuzzification: This is the transformation of fuzzy outputs into an absolute crisp value. A crisp value is thereby obtained as the consequence of implication and aggregation. There are two types of fuzzy inference system:
  • Mamdani-type fuzzy inference system: It is simple, straightforward to formalize, highly interpretable, widely accepted, and the most appropriate for human input. This paper presents work on the Mamdani-type fuzzy system [30,31].
  • Sugeno-type fuzzy inference system: It works better with adaptive and optimization techniques, and control problems. It is highly computationally efficient, and is ideally suited for no dynamic linear systems [32].

3.2. Data Clustering

Clustering is simply a method for grouping the unlabeled data [33,34,35]. On a behavioral basis, it is categorized into two types:

• Hard clustering: In this algorithm, each pattern lies exactly on one cluster, i.e. there are no overlapping groups and no probability calculation.
• Soft clustering: In this technique, each data point can belong to multiple clusters with some degree of membership. Soft clustering can be transformed into hard clustering by assigning each data point to the cluster having the highest membership.

Out of several clustering algorithms, the K-means FCM (Fuzzy C-means) is famous among researchers because of its correctness and closeness to output. K-means is a traditional hard-clustering algorithm which needs prior knowledge about the number of clusters.

4. Proposed Model

The optimum goal of our proposed model (presented in Figure 2) is to provide a definitive solution for quality-assurance personnel in uncertainty and ambiguity, which ultimately produces highly reliable, enhanced-quality components needing less maintenance.

4.1. Software Component Development Phases

There are six complete phases in software-component development.

• Domain analysis and specification: This is an envisioning phase, in which the development team defines the structure and objectives of solutions (including requirements, use case, technologies, interfaces, performance and operating environment).
• Design: This is a conceptual design phase that assigns functional logic in the architecture, and that realizes components via data-exchange mechanisms in interactions and via approaches in component packaging and deployment.
• Coding: This is the implementation phase, executed with specific technology and programming languages on a targeted operating environment.
• Testing: This is a validation phase for a software component, considering its specifications and design. It includes both black- and white-box testing, and provides all testing reports.
• Packaging and deployment: This phase ensures components’ customization, packaging, deployment approach, and tunes its configuration for a particular environment.
• Maintenance: This phase collects feedback and requests from users to enhance and upgrade it.

4.2. Designing Metric

To ensure the reliability and quality of the component-based system, it is important to assure that the components are defect free. The two-code designing metric used is as follows:

• Inspection Rate: In the real inspection session, the inspectors study the program and search for mistakes. The inspection rate is calculated by dividing the number of source lines without comments that have been examined by the length of the inspection session. Inspection rate is not an entirely separate variable. It is influenced by the rate of defect identification, which is in turn influenced by the degree of planning and the frequency of errors in the code. It was determined that the inspection rate and the density of errors identified had an inverse correlation.
• Size of Code: It had been discovered that the primary factor affecting the planning and the inspection rate is the size of the code that had been inspected. In general, larger modules of code received relatively less research and underwent inspections more frequently. For bigger units of code, this led to a reduced density of identified mistakes. A reduced rate of inspection during the session and a high rate of preparatory work compared to the code size were two characteristics of the tiny to reasonably-sized coding units. As a consequence, these chunks of code usually had greater densities of identified mistakes.

Suppose $C_1,C_2,C_3\dots C_n$ are the total number of components under development, and that $I_1,I_2,I_3\dots I_n$ are the inspection session times (in hours), i.e. inception hour denoted by Hr for a component respectively. The size of the component in the Line of Code (LOC) is $L_1,L_2,L_3\dots L_n$, and defects in each component may vary from 0 to some countable number. Furthermore, on this basis, two metrics, i.e. inspection rate and error density, can be designed [36].

Thus, Inspection Rate:

$$I_r=\frac{LOC}{Hr}$$

(2)

Fault Density:

$$F_d=\frac{Numberoferrors}{LOC}$$

(3)

4.3. Early Reliability Prediction

Finding the elements that significantly affect software reliability and the quantity of residual errors is the first step in creating an evaluation model for software quality. However, finding the precise key-quality elements is quite challenging. Additionally, it is challenging to determine the exact level of effect. In other words, even when discrete, accurate metric data are employed, and the inference methods may be of a fuzzy character.

Consider the following scenario: an usual inspection rate is between 150 and 200 LoC/Hr [35], however, an inspection team reported an inspection rate of above 380 LoC/Hr. One may make a strong case for why such inspection rates are substantially higher than the average from published commercial processes, and specialists will almost certainly all concur with the result. However, since the word "substantially" cannot be measured with accuracy, such an evaluation is ambiguous. Additionally, if a team claims an inspection rate of 275 LoC/Hr, professionals are likely to disagree over whether and how far the inspection rate deviated from the industry standard. In other words, the discriminator is vague. In circumstances when approximate reasoning is required, fuzzy logic is a compelling choice because of its inherent capacity to model imprecise and fuzzy aspects of data and rules. Without depending on a large amount of training data, a working prototype may also be created using only domain expertise. As additional information becomes available, the system’s effectiveness may also be incrementally adjusted.

In this paper, we are proposing an early reliability-prediction phase in the component development model. This phase is very significant to yield a more reliable and high-quality component. A designed algorithm for premature reliability phases is:

• Choose the most suitable defect-detection technique from industry practices such as voting, inspection, walkthrough, self-checking, and data-flow analysis. (Fagan inspection is costlier but shows better outcomes.)
• Inspection is a peer review of the early development phase by trained and experienced personnel, having a well-defined approach [37]. Obtaining an examination report provides inspection hours, the size of code, and a total number of found faults.
• Realize the metric inspection rate and fault density using Equations (2) and (3).
• Normalize the values for proper scaling between [0–1] by using min-max normalization.
• If experts are available with good domain knowledge, then design a Mamdani-FIS, else determine the suitable clustering technique and design a Mamdani fuzzy inference system using data sets. Personnel can judge both accuracy and differentiation.
• Select the optimized result, and on that basis reject the defect-prone component. Then move high-grade components to test beds for functionality and performance testing, and continue the following phases.

5. Case Study

We are considering one of the promising data sets, LIP (Launch Inceptor Programs) and Conflicts data from Knight et al. [38], which was further re-evaluated by Sun Sup So et al. [39] on real-time through-voting, instrumentation, and Fagan inspection; Sun Sup So et al. conclude that Fagan inspection is cost-effective but gives better results. For experimentation, we took data from our procurement model from Sun Sup So et al. [40]. The data set contains found defects and exactly-known defects that help in analyzing performance and accuracy of the proposed model. For our experiment, we used data of 35 components. We designed two fuzzy inference systems, one based on experts’ opinion and another based on a self-learning FCM algorithm.

5.1. Experts’ Opinion Rule Base Mamdani-FIS

To estimate the components’ premature reliability, which is the main aim of the proposed model, we are considering two metrics as our input variable, i.e. inspection rate and defect density. We have categorized each input variable into three clusters. For inspection rate they are Slow, Moderate, and Fast, and for defect density Low, Medium, High. The output variable, i.e. predicted reliability, is classified into four membership functions, D-grade, C-grade, B-grade, and A-grade. Using expertise and domain knowledge, we have framed 3² = 9 fuzzy rules from these input variables. The rules are:

• If inspection rate is Fast and defect density is High, then the reliability index is grade-D.
• If inspection rate is Fast and defect density is Medium, then the reliability index is grade-C.
• If inspection rate is Fast and defect density is Low, then the reliability index is grade-B.
• If inspection rate is Moderate and defect density is High, then the reliability index is grade-C.
• If inspection rate is Moderate and defect density is Medium, then the reliability index is grade-B.
• If inspection rate is Moderate and defect density is Low, then the reliability index is grade-A.
• If inspection rate is Slow and defect density is High, then the reliability index is grade-C.
• If inspection rate is Slow and defect density is Medium, then the reliability index is grade-C.
• If inspection rate is Slow and defect density is Low, then the reliability index is grade-B.

5.2. Evaluation of Model

Let us suppose we have crisp inputs to the model, whereby inspection rate is 0.1672 and defect density is 0.1556. This implies that inspection rate is moderate and defect density is low, so the predicted reliability is Grade-A. In Matlab, rules trigger consequents if antecedents are true, resulting in a crisp defuzzifed output. Hence, the predicted reliability found in this case is 0.9. The defuzzification method used in this case is centroid. Figure 3 represents the input and output membership functions of experts’ opinion-based systems. The triangular membership function is used for fuzzification of input. Figure 3 clearly depicts the degree of membership corresponding to a crisp input and output value, for example: an inspection rate value of 0.25 corresponds to 0.07 degrees of membership of Moderate and 0.005 degrees of membership of the Fast category. Figure 4 depicts the surface view of experts’-based M-FIS. Figure 4 clearly depicts the 3D view of the reliability value corresponding to the possible input-space of inspection rate, and defect density when reliability is predicted through M-FIS.

The fuzzy system presented in Figure 3 and Figure 4 is dependent on the knowledge of experts. This paper investigates the impacts of introducing a fuzzy system in decision making, considering reliability of the software. The system built through expert-based MFIS (presented in Figure 3 and Figure 4) showcases reasonably-acceptable results corresponding to given inspection rate and defect density. However, the accuracy of the system depends much on the knowledge of experts.

5.3. Self-Learning FCM Mamdani-FIS

This method uses input/output data sets to generate a Mamdani fuzzy inference system through ‘genfis’ (Matlab 2017). The model captures the behavior of data through an unsupervised or self-learning approach of the Fuzzy-C means algorithm. Hence, the model can predict reliability. Here, we are dividing data sets into a ratio of 66:33, training and testing the sets like neural networks. The M-FIS structure consists of Gaussian membership functions for both input(s) and output. Moreover, the Mamdani fuzzy-inference system is analogous to the zero-order Sugeno fuzzy model, and functionally equivalent to the radial basis-function network in certain minor constraints [41,42]. Furthermore, the Gaussian function has the fewest modifiable parameters (only 2): it can shift monotonically from its center. The rules are auto generated: three clusters and three rules. We can use testing data to see the accuracy of reliability prediction.

5.4. Evaluation of the Model

Let us consider the same data as a crisp input to the model, given an inspection rate of 0.1672 and a defect density of 0.1556. Here, rules auto-generate via self-learning, with the predicted reliability in this case found to be 0.8470. The defuzzification method used is centroid. Figure 5 represents the input and output membership functions of self-learning (FCM) M-FIS. The Gaussian membership function is used for fuzzification of the input. Figure 5 clearly depicts the degree of membership corresponding to crisp input and output values, for example: a defect-density value of 0.6 corresponds to 0.23 degrees of membership of Medium, and 0.69 degrees of membership of the High category. Figure 6 depicts the surface view of self-learning (FCM) M-FIS. Figure 6 clearly depicts the 3D view of the reliability value corresponding to the possible input space of inspection rate, and depicts defect density when reliability is predicted through self-learning (FCM) M-FIS.

6. Results and Discussion

In this article, we have presented a dual Mamdani fuzzy-inference system, one based on a human intuitive experts’ opinion system and another using an unsupervised or self-learning Fuzzy C-means algorithm.

Figure 7 shows the plot of experts’-based reliability, self-learning FCM reliability, against actual reliability. To evaluate the impact of incorporating fuzziness, we have incorporated the results of the K-Means algorithm on crisp data. The fact is that experts are human; they can have incorrect and incomplete knowledge or may not completely transfer information to knowledge engineers. Another fact is simple and focuses the industry’s expectation and requirements: it is cost efficient and more consistent, as experts are tougher to find and quite expensive.

Table 2. Results summary predicted reliability and actual reliability.

Component Name	Inspection Rate (Nor.)	Defect Density (Nor.)	Actual Reliability	Predicted Experts’ M-FIS	Predicted Self-Learning M-FIS	Predicted K-Means
Conflict 6-2	0.1136	0.5839	0.8208	0.9000	0.7071	0.6548
Conflict5-1	0.0966	0.3226	0.8640	0.7492	0.7846	0.8564
LIP12-1	0.1672	0.1556	0.8099	0.9000	0.8296	0.7465
LIP3-2	0.6369	0.0010	0.8692	0.7500	0.8061	0.9547
Conflict8-5	0.2036	0.0930	0.9152	0.9000	0.8456	0.7549
LIP12-2	0.2430	0.0010	0.9250	0.8000	0.8580	0.9854
Conflict2-1	0.3294	0.2749	0.8304	0.7500	0.7945	0.8947
LIP3-3	0.2261	0.2036	0.9468	0.9000	0.8176	0.7458
Conflict8-2	0.1442	0.4984	0.8448	0.9000	0.7411	0.6487
LIP12-4	0.3861	0.0010	0.9206	0.7500	0.7907	0.9571
LIP3-1	0.2013	0.1018	0.9087	0.9000	0.8439	0.7654

presents the summary of predicted reliability (for fuzzy and crisp data) and actual reliability.

The accuracy of proposed models is measured through mean absolute error (MAE) and root mean square error (RMSE) (results presented in

Table 3. Model error results.

Model	MAE	RMSE
Predicted Experts’ based M-FIS reliability	0.0823	0.0946
Predicted Self-learning M-FIS reliability	0.0796	0.0867
Predicted K-Means	0.1077	0.1254

).

$$MAE=\frac{1}{n}{\displaystyle \sum }_{k=1}^n|{\alpha }_k-{\tilde{\alpha }}_k|$$

(4)

$$RMSE=\sqrt{\frac{1}{n}}{\displaystyle \sum }_{k=1}^n{\left({\alpha }_k-{\tilde{\alpha }}_k\right)}^2$$

(5)

where $n$ is the number of observations, ${\alpha }_k$ is actual reliability, and ${\tilde{\alpha }}_k$ is predicted reliability.

It can be concluded that the self-learning approach shows less error than experts’-based M-FIS. However, this may not be true for every case. There is always a possibility of better outcomes and performance in experts’-based M-FIS. Furthermore, the dual approach can be a basis for cross validation. Further, it is evident that incorporating fuzziness has improved the prediction.

Additionally, a sensitivity analysis is done to find the sensitive factors. Sensitivity analysis is a crucial technique for analyzing mathematical representations of actual problems. A thorough investigation of variable sensitivity provides a comprehensive set of predictions that illustrate how modifications to a model-parameter may impact pertinent model outcomes. A variable is a quality, a quantifiable element, or a property that can aid in defining a certain system. By resolving the model and analyzing the results with regard to modifications introduced with variables in the model’s solution space, it is possible to identify the impacts of changing a model’s variables.

Sensitivity analysis is performed using the following steps:

• Choose the variable that will be investigated.
• Assume values for each variable.
• Execute the simulation using the chosen series while maintaining the other variables at their default values.
• Determine the goal function for each property-evaluation metric.
• Determine the findings’ percentage difference and categories each variable correspondingly.
• Evaluate every variable’s relative importance.

Using the above-mentioned steps, it has been observed that among the input parameters (i.e., inspection rate and defect density), defect density is the sensitive factor affecting the identification of software reliability.

The primary objective of this work is to find the optimal solution for project managers and quality personnel, given circumstances of ambiguity and uncertainty. We have designed two Mamdani fuzzy-inference systems, one based on experts and another based on unsupervised or self-learning. Reliability optimization is made by rejecting weak designed components in the early phase of development.

Although many researchers have proposed several methods for estimating component-based system reliability, only a few researchers estimated components’ reliability while estimating the overall reliability. The remaining models are accurate and show good performance, but consider components and reliability on guarantee, or use developers’ or vendors’ authority to estimate the reliability of CBS, which is practically infeasible. Hence, these works encourage us to study and optimize components and reliability, and to meet their requirements and produce high-quality components.

The article presents the dual Mamdani fuzzy-inference system, one based on an expert and another on self-learning FCM, to compute the reliability of a software component. From the experimentation, it is found that the self-learnt Mamdani model yields better results with less error. Therefore, in the absence of experts and the industry’s profound demand for maximum automation, this technique can be quite useful.

The current research work establishes the rules, number, and types of membership functions, training samples to refine an M-FIS model. The end user can enhance the software inspection in the development phase. The automated inspection can set new trends and fits the industry expectation. This work examines and increases the feasibility of developing more reliable software components.

7. Conclusions

Although many researchers have proposed several methods for estimating component-based system reliability, only a few researchers estimated components’ reliability while estimating the overall reliability. The remaining models are accurate and show good performance, but consider components’ reliability on guarantee, or use developers or vendors’ reliability to estimate the reliability of CBS, which is practically infeasible. Hence, these works encourage us to study and optimize components’ reliability, also to meet their requirements and produce high-quality components. This article presents the dual Mamdani fuzzy-inference system, one part based on an expert and another on self-learning FCM, to compute the reliability of a software component. From the experiment, it is found that the self-learnt Mamdani model gives better results with less error. Therefore, given the absence of experts and the industry’s profound demand for maximum automation, the proposed technique can be quite useful.