Clustering is a process to group data into different data sets, so as to reveal patterns in the data and to provide a concise representation of the data behavior. The iEF reasoning framework is based on the Takagi-Sugeno (TS) method with the following form:

${\Re }_j$: If ( $x_1$ is $A_{1,j}$) and… and ( $x_n$ is $A_{n,j}$) then $y=y_j$ (with weight $w_1$) (1)

where ${\Re }_j$ denotes the jth fuzzy cluster/rule, $j\in \left[1,R\right]$, and R is the total number of fuzzy clusters/rules; $A_{i,j}$ is the jth fuzzy set for $x_i$, $i\in \left[1,n\right]$; $y_j=\left[y_{j1},y_{j2},\cdots \text{,}{y}_{jM}\right]$ are the output fuzzy sets, in this case, related to healthy, possibly damaged, and damaged categories. $w_j$ is the weight factor representing the contribution of rule ${\Re }_j$ to the pattern classification.

In the proposed iEF technique, all the fuzzy set membership functions (MFs) are in Gaussian form

${\mu }_{A_{i,j}}=\exp \left(-\frac{{\left(x_i-m_{i,j}\right)}^2}{2{\sigma }_{i,j}^2}\right)$ (2)

where $m_{i,j}$ and ${\sigma }_{i,j}$ are the centers and spreads of the MF, respectively. A Gaussian function not only has properties of continuity and generalization, but also can be decomposed into multiple one-dimensional Gaussian MFs corresponding to different input variables. These properties can facilitate the implementation of input/output partition if each cluster is treated as a fuzzy cluster (rule) [14] .

If a max-product operator is used for the premise fuzzy reasoning, the rule firing strength will be

${\mu }_j={\displaystyle \underset{i=1}{\overset{n}{\prod }}{\mu }_{A_{i,j}}\left(x_i\right)}={\displaystyle \underset{i=1}{\overset{n}{\prod }}\exp \left(-\frac{{\left(x_i-m_{i,j}\right)}^2}{2{\sigma }_{i,j}^2}\right)}$ $=\exp \left(-{\displaystyle \underset{i=1}{\overset{n}{\sum }}\frac{{(x_i-m_{i,j})}^2}{2{\sigma }_{i,j}^2}}\right),j\in \left[1,R\right]$ (3)

After normalization of the rule firing strengths, the overall output will be

$y={\displaystyle \underset{j=1}{\overset{R}{\sum }}\frac{{\mu }_j}{{\mu }_{\sum }}}{q}_j{w}_j$, $j\in \left[1,R\right]$ (4)

where $q_j$ is the result from the consequent part, and the firing strength of the jth rule is normalized by

${\mu }_{\sum }={\displaystyle \underset{j=1}{\overset{R}{\sum }}{\mu }_j}={\displaystyle \underset{j=1}{\overset{R}{\sum }}\exp \left(-{\displaystyle \underset{i=1}{\overset{n}{\sum }}\frac{{\left(x_i-m_{i,j}\right)}^2}{2{\sigma }_{i,j}^2}}\right)}$ (5)

The iEF is a data-driven, non-iterative, and one-pass method. Different from the general potential-based methods, iEF partitions input and output spaces simultaneously to keep input/output mapping consistency and remove the noise-affected outliers. It recursively updates the cluster centers and spreads, so as to make the generated clusters well-distributed over the input-output spaces. Different from other evolving algorithms, the partitioning of the output space of the proposed iEF is performed according to the machine health conditions. The processing procedures are discussed below.

Step 1: Initialize the parameters: The initial iEF classifier has an empty rule base. Input the first data sample $z_k=\left[x_k\text{,}{y}_k\right]$, $k:=$ 1, which defines the first cluster center: $c_k:=z_k$. Then, $R:=$ 1, $N_r:=$ 1, $m_{R,I}:=x_k$, ${\sigma }_{R,I}:=$ 0.10, $m_{R,O}:=y_k$, ${\sigma }_{R,O}:=$ 0.10, $P_k\left(z_k\right):=$ 1, $P_k\left(c_k\right):=$ 1, where $N_r$ is the number of samples in cluster r, $r\in [1,R]$ and R is the number of clusters/rules; $m_{R.I}$, $m_{R.O}$, ${\sigma }_{R.I}$ and ${\sigma }_{R.O}$ are the cluster centers and spreads in the input and output spaces, respectively. $P_k\left(z_k\right)$ is the potential of data sample $z_k$, and $P_k\left(c_k\right)$ is the potential of the center $c_k$.

Step 2: Compute the potential: Input the next data sample, $z_k=\left[x_k\text{,}{y}_k\right]$; $k:=k+1$. The potential of $z_k$ is calculated by

$P_k\left(z_k\right)=\frac{k-1}{\left(k-1\right)\left({\theta }_k+1\right)+{\sigma }_k-2v_k}$ (6)

where ${\theta }_k={\displaystyle \underset{i=1}{\overset{n}{\sum }}{\left(z_{k.i}\right)}^2}$; ${\sigma }_k={\sigma }_{k-1}+{\displaystyle \underset{i=1}{\overset{n}{\sum }}{\left(z_{k-1.i}\right)}^2}$; $v_k={\displaystyle \underset{i=1}{\overset{n}{\sum }}{z}_{k.i}{\beta }_{k.i}}$; ${\beta }_{k,i}={\beta }_{k-1,i}+z_{k-1,i}$; ${\beta }_{k.i}$ and ${\sigma }_k$ are initialized to zeros; n = dimension of the inputs $z_k=\left[x_k,y_k\right]$.

Step 3: Update of existing clusters: The potential of all existing clusters at time instant k are recursively updated by:

$P_k\left(c_r\right)=\frac{\left(k-1\right)P_{k-1}\left(c_r\right)}{\left(k-2\right)+P_{k-1}\left(c_r\right)+P_{k-1}\left(c_r\right){\displaystyle \underset{i=1}{\overset{n}{\sum }}{\left(z_{k,i}-z_{k-1,i}\right)}^2}}$ (7)

where $c_r$ represents the x and y coordinates of all existing clusters, $r\in \left[1,R\right]$.

Step 4: Determine the winning cluster: The winning cluster is determined based on the following law:

1) If $P_k\left(z_k\right)<P_k\left(c_r\right)$, or the potential of the current data point is less than the potential of all existing clusters, then go to Step 6 and update consequent parameters.

2) If $P_k\left(z_k\right)\ge P_k\left(c_r\right)$, then determine the winning cluster in the input space and output space, respectively:

$W{C}_I=\arg \underset{k=1}{\overset{K}{\min }}\Vert m_{k,I}-x_{k,I}\Vert$

$W{C}_O=\arg \underset{k=1}{\overset{K}{\min }}\Vert m_{k,I}-y_{k,I}\Vert$

where $k\in [1,K]$, and K is the total number of data pairs.

Step 5: Recognize the fuzzy cluster structure: If $W{C}_I=W{C}_O$, then merge the new data set to the winning cluster. The winning cluster parameters are updated in the input space and output space, respectively, whereas the other cluster information remains unchanged:

${\left({\sigma }_{k,I}\right)}^2:={\left({\sigma }_{k-1,I}\right)}^2+\frac{1}{N_W}\left[{\left(x_k-m_{k-1,I}\right)}^2-{\left({\sigma }_{k-1,I}\right)}^2\right]$

$m_{k,I}:=m_{k-1,I}+\frac{x_k-m_{k-1,I}}{N_W}$

${\left({\sigma }_{k,O}\right)}^2:={\left({\sigma }_{k-1,O}\right)}^2+\frac{1}{N_W}\left[{\left(x_k-m_{k-1,O}\right)}^2-{\left({\sigma }_{k-1,O}\right)}^2\right]$

$m_{k,O}:=m_{k-1,O}+\frac{x_k-m_{k-1,O}}{N_W}$

where $N_W$ is the number of samples in the winning cluster.

If $W{C}_I\ne W{C}_O$, then there is no winning cluster. Create a new cluster: $R:=R+1$, $N_R:=1$, $m_{R,I}\leftarrow x_k$, ${\sigma }_{R,I}:=$ 0.10; $m_{R,O}:=y_k$, ${\sigma }_{R,O}:=$ 0.10.

These criteria are applied to exclude those clusters affected by noise. For example, two closest clusters may not be merged to one cluster if they belong to different output classes.

Step 6: Update the consequent weight parameters: The optimization is taken by the use of the hybrid training method to be discussed in the following subsection.

Step 7: Calculate the classification output: The output is computed by Equation (4). Proceed back to Step 2, until all the data samples have been input into the system (i.e., k = K).

Once the iEF reasoning structure is identified, as discussed in Section 2.2, the parameters (both linear and non-linear) should be properly optimized to improve diagnostic classification accuracy. Linear parameters will be trained by the use of the general LSE method. The non-linear parameters will be optimized by the use of the proposed EKF.

Many training algorithms have been proposed in the literature for non-linear parameter optimization, such as the classical gradient algorithms, Levenberg-Marquardt, and Kalman filtering (KF) [14] [21] . The gradient descent (GD) algorithm is prone to being trapped by local minima; whereas Levenberg-Marquardt method cannot be effectively used for large models that will generate oversized variance matrices and significantly slow down the processing convergence. Among the KF-associated methods, the node decoupled KF (NDKF) algorithm can simplify implementation and reduce memory requirements, which outperforms other KF-related algorithms [22] . However, the accuracy of the NDKF is limited due to its sensitivity to the implementation strategy. The classical NDKF takes two steps in operation: updating and prediction [23] . In the prediction step, the posteriori states are used to estimate the state at the current time step. In the update step, the priori prediction is combined with the current information to update the state estimate and the posteriori error covariance matrix. Consider a multivariable system in the following form:

$x_k=F_k{x}_{k-1}+u_{k-1}$ (8)

$y_k=H_k{x}_k+v_k$ (9)

where $x_k$ is a state vector $\left(n\times 1\right)$; $F_k$ is a transition matrix $\left(n\times n\right)$; $y_k$ is an observation vector $\left(1\times n\right)$; $H_k$ is an observation matrix $\left(1\times n\right)$; $u_k$ and $v_k$ are the respective process noise and observation noise, which satisfy the following conditions:

$E\left(u_k\right)=E\left(v_k\right)=0$

$E\left(u_k{u}_i^T\right)=\{\begin{array}{l}{Q}_k\text{if}i=k\\ 0\text{if}i\ne k\end{array}$ (10)

$E\left(v_k{v}_i^T\right)=\{\begin{array}{l}{R}_k\text{if}i=k\\ 0\text{if}i\ne k\end{array}$

where $E(\cdot )$ denotes the expectation, $Q_k$ and $R_k$ are the respective process noise matrix and observation noise covariance matrix. In the prediction step, the predicted state is

${\hat{x}}_{k|k-1}=F_k{\hat{x}}_{k-1|k-1}$ (11)

where the subscript “k|k − 1” denotes the estimate at time instant k given observations up to steps k − 1. The predicted estimate covariance matrix becomes

$S_{k|k-1}=F_k{S}_{k-1|k-1}{F}_k^T+Q_k$ (12)

where $S_{k-1|k-1}=\mathrm{cov}\left(x_k-{\hat{x}}_{k|k}\right)$. In the updated step, the measurement residual is computed as:

${\tilde{d}}_k=y_k-H_k{\hat{x}}_{k|k-1}$ (13)

The optimal Kalman gain will be

$K_k=S_{k|k-1}{H}_k^T{\left(H_k{S}_{k|k-1}{H}_k^T+R_k\right)}^{-1}$ (14)

State estimate is updated by

${\hat{x}}_{k|k}={\hat{x}}_{k|k-1}+K_k{\tilde{d}}_k$ (15)

Estimate covariance matrix is updated by:

$S_{k|k}=S_{k|k-1}+K_k{H}_k{S}_{k|k-1}$ (16)

The KF performance depends on process noise covariance matrix Q and observation error covariance matrix R, which are related to the application and process dynamics [24] . The DEKF filter may diverge from the optimum due to Q and R errors. Generally, the covariance matrices are determined based on trials and errors. However, for a complex dynamic system like a gearbox, it is difficult to determine the reasonable covariance matrices in advance. On the other hand, empirical approximation process may result in significant errors, which makes the training method unreliable. Correspondingly, a covariance matrix updating method, EKF, will be proposed in this work to improve the performance of DEKF.

The covariance provides a measure of correlation between two or more random variables. The proposed EKF method is to update process noise and observation error covariance matrices, which are defined as:

$V_k={\left(H_k{S}_{k|k-1}{H}_k^T+R_k\right)}^{-1}$ (17)

where $S_{k|k-1}=F_k{S}_{k-1|k-1}{F}_k^T+Q_k$.

The process noise and observation error are updated by

$R_{k|k}=R_{k|k-1}+R_{k|k-1}{\left(V_k\right)}^{\beta }$ (18)

$Q_{k|k}=Q_{k|k-1}-Q_{k|k-1}{\left(V_k\right)}^{\beta }$ (19)

where $\beta \in \left[0,1\right]$ is a design parameter. By systematic investigation, $\beta =\frac{1}{2R}$ will be utilized in this work, where R is number of clusters.

The process noise covariance matrix and observation error covariance matrix are diagonal matrices initialized at 0.01 and 0.80, respectively. A series of simulation tests have been performed with initialization values ranging between 0.0001 and 1. After each epoch, the noise covariance matrix and observation error covariance matrix are updated using Equation (18) and Equation (19), respectively.

During the training using the EKF, with the introduction of the scaling factor, the predicted estimate covariance matrix S changes at a slower rate, whereas the process noise covariance matrix and observation error covariance matrix change at a faster rate. Since all covariance matrices are being updated, the state estimate update is more robust, making the training process more reliable, as can be noted in Section 3.

After the iEF reasoning structure is identified, system parameters will be trained by the use of a hybrid method. In the forward pass, the non-linear premise parameters are optimized using the proposed EKF method, while the linear parameters remain fixed. In the backward pass, non-linear MF parameters remain unchanged, but linear consequent weight parameters are updated using the LSE algorithm [13] . A hybrid method usually has merits of reducing the trapping of local minima and improving the training convergence [16] .

Two benchmark data sets are used for these simulation tests.

The first simulation test is undertaken using the Iris Dataset [25] . Iris dataset has 4 inputs: sepal length (x₁), sepal width (x₂), petal length (x₃), and petal width (x₄). It has 3 output states or classes: Iris Setosa, Iris Versicolour, and Iris Virginica. This test is conducted using 150 data pairs, 80 of which are used for training and remaining 70 are used for testing. The simulation is undertaken using MATLAB 2023b. In classification, once the clusters are generated, the classifier will calculate the system output. The related training algorithms are used to optimize classifier linear and non-linear parameters. Table 1 summarizes the comparison results using the related classifiers. All of the selected classifiers are operated to achieve optimal results based on the input data. The success rates of each classifier represent the accuracy values before and after training. It is clear that the related training algorithms can clearly improve classification accuracy.

From Table 1 , it is seen that during the verification test, the TWNFI performs better than the eTS classifier (85.84% vs. 75.67%), even though both have generated 5 clusters. The SEF and iEF classifiers have generated 3 clusters only, which can speed up the classification convergence. However, the iEF-DG outperforms the SEF (79.46% vs. 85.73%) due to iEF’s more efficient evolving algorithm, which can also be related to the formulation of 4 rules vs. 3 rules of the SEF. Comparing iEF-GD and iEF-EKF, it is clear that the proposed EKF method can effectively control weights of the iEF system to improve diagnostic accuracy (95.34% vs. 85.73%) and processing efficiency (1.39 sec vs. 1.56 sec per epoch).

Figure 1(a) shows the verification process of the developed iEF-EKF technique for the Iris data. It generates four false indicators in classification, which misclassify the output data. Figure 1(b) represents the absolute errors during the testing process.

Another simulation test is undertaken using the Wisconsin Breast Cancer Dataset [26] to check the robustness of the proposed iEF-EKF classifier. This dataset has four input variables: glucose (x₁), homa (x₂), adiponectin (x₃), and MCP (x₄). The output has two classes: benign and malignant; or the output space is divided into 2 classes to be unbiased.

A total of 116 data pairs are selected for analysis: 60 for training and remaining 56 for verification testing. The classification results are summarized in Table 2 . It is seen that the training can clearly improve the classification accuracy. In terms of the number of formulated clusters, the SEF and iEF are more efficient in the evolving process than the TWNFI and the eTS classifiers (i.e., 4 clusters vs. 2). Since the SEF classifier adopts 2 rules only, it results in the lowest classification accuracy in this case. With the comparison of the SEF and the iEF methods (i.e., iEF-GD and iEF-EKF), it is clear that the proposed iEF evolving method is more efficient than the related methods. The iEF-EKF outperforms the iEF-GD in terms of classification accuracy (89.21% vs. 84.07%) and processing speed (0.63 sec vs. 0.88 sec), due to its efficient EKF training.

Figure 2(a) shows the processing results of the iEF-EKF classifier; it generates 4 missed alarms and 3 false alarms. Figure 2(b) shows the absolute testing errors.

Gear fault can be classified into two categories: localized defects (e.g., broken tooth and chipped tooth) and distributed defects (e.g., scoring and wear). This work will focus on localized gear fault diagnosis because a localized fault will not only degrade transmission accuracy but also may cause sudden failures. In this work, the gear fault diagnosis is conducted gear by gear. As the measured vibration signal is generated from various vibratory sources in a gearbox, the first step is to differentiate the signal specific to each gear of interest by using a time synchronous average filter [6] . As a result, each gear signal can be processed and represented in one full revolution, called the signal average.

Many techniques have been proposed in the literature for gear fault detection, however, each technique has its own advantages and limitations. Each technique could be efficient for specific applications only. In this work, as discussed in Introduction, three features will be selected for this diagnostic classification from three information domains: energy, amplitude, and phase:

1) Beta kurtosis index (x₁): Using the overall residual signal obtained by band-stop filtering out the gear mesh frequency f_rZ and its harmonics (up to the 5^th harmonic), where f_r is the gear rotation frequency (Hz) and Z is the number of teeth of the gear.

2) Wavelet energy index (x₂): Also using the overall residual signal.

3) Phase demodulation index (x₃): Using the signal average.

Details of these signal processing techniques and filtering procedures can be found in papers [6] [8] . The determination of the monitoring indices can be found in paper [6] , both of which are from the authors’ research team.

Figure 3 shows the experimental setup used for performing this test.

This system is driven by a 2.2 kW induction motor, with speed ranging from 50 rpm to 4200 rpm. The motor speed is changed by using a variable frequency speed controller (VFD022B21A). A flexible coupling is used to dampen the high-frequency vibration components and shocks from the motor. An optical sensor (ROS-W, 40 mA and 3 - 15 V) is used to provide a one-pulse-per-revolution signal, used for time-synchronous average filtering operations.

The tested gear system is shown in Figure 4(a) , which consists of two pairs of spur gears. The first pair has 32 and 80 teeth for the pinion and the gear, respectively. The second pair has 96 and 48 teeth for the pinion and the gear, respectively. A magnetic brake unit (B150-24-H, Placid Industries) is used to provide dynamic loads to the gear system. The vibration signals are collected using ICP accelerometers (SN98697, ICP-IMI) with sensitivity of 100 mV/g. These ICP sensors are mounted on the gearbox housing to collect data along different directions. These sensors are connected to a data acquisition board (NI PCI-4472), attached to a computer. A software interface has been developed to control the data acquisition operations in real-time, in terms of the sensor network, sampling frequency, data size, etc.

Three gear health states (classes) are tested as illustrated in Figure 5 :

1) Healthy gear: 52 data sets are collected for analysis;

2) Cracked gear: 67 data sets are collected;

3) Partially broken gears: 74 data sets are collected for analysis, as shown in Figure 4(b) .

The health conditions of each gear are constrained to three state classes: C₁ = healthy, C₂ = cracked tooth damage, C₃ = partially broken tooth damage. In processing, the scopes are selected as: health C₁ if $y\in \left[0,0.33\right]$, crack gear damaged C₂ if $y\in \left(0.33,0.67\right]$, and partially broken tooth damage C₃ if $y\in \left(0.67,1.0\right]$.

Similarly to the conditions in simulation tests in Section 3.1, five related classifiers are used for comparison: eTS, TWNFI, SEF, iEF-DG and iEF-EKF. All of these classifiers have three inputs, and with same training conditions.

Tests are undertaken under different load and speed conditions. The sampling frequency is selected to make sure each tooth period contains about 50 data samples. For example, if the shaft speed is 1200 rpm, or f_r = 20 Hz, the gear has Z = 32 teeth, the sampling frequency should be about: f_s = 32 teeth × 50 samples × 20 Hz ≈ 32,000 Hz.

Once the gear signal is collected, it is first processed by the use of the time synchronous average filtering to get signal average. Then the signal average is further processed to generate the monitoring indices of beta kurtosis (x₁), wavelet amplitude (x₂) and phase information (x₃), which are input variables to the classifiers.

In processing, 157 data sets are used for healthy gear condition monitoring (70 for training, 32 for validation and 55 for testing); 108 data sets are used for cacked gear condition monitoring (48 for training, 25 for validation and 35 for testing); and 117 data sets are used for partially broken gear condition monitoring (55 for training, 20 for validation and 42 for testing).

Table 3 summarizes the diagnostic results using related classification techniques. In gear fault diagnosis, two types of errors are considered: 1) false alarm: the recognized gear fault is caused by other reasons (e.g., speed/load variations) instead of real gear defect; 2) missed alarm: the gear fault is not recognized by the diagnostic classifier. From Table 3 , it is seen that the proposed iEF technique outperforms the classical eTS and TWNFI classifier, as well as the SEF classifier, with fewer clusters and higher diagnostic accuracy. That is mainly because the iEF technique has a more efficient evolving approach with the appropriate partition strategy. On the other hand, with the comparison of iEF-GD and iEF-EKF, the proposed EKF training method can improve not only classification accuracy (99.34% vs. 96.57%), but also processing efficiency (1.62 sec vs. 1.87 sec per epoch), which makes it more suitable for real-time monitoring applications.

Figure 6(a) shows the classification process of the iEF-EKF classifier during the testing process. It is seen that iEF-EKF classifier is efficient in separating healthy state from the faulty state of the gearbox, but it has generated some errors in gear fault diagnosis with two false alarms and one missed alarm. Figure 6(b) illiterates the absolute errors.

Figure 7 illustrates the output clusters (dotted circles) and the recognized clusters in the output space using the iEF-EKF classifier, as indicated by the solid lines, in terms of x₁ (beta-kurtosis) versus x₂ (wavelet energy amplitude). Figure 8 shows the recognized fuzzy model architecture after 50 training epochs, after all of the training data sets have been input to the classifier. It is a 6-layer network. During the evolving process, this structure is updated gradually and continuously. Initially, each input variable (in layer 1) had 3 MFs (in layer 2): S., M. and L. that are related to each cluster formation. After the evolution, 3 clusters are generated, which result in 4 rules, R₁ - R₄. Both x₁ and x₃ have three MFs: S., M. and L. On the other hand, x₂ has two MFs only: S₂ and L₂. S₂ is related to R₁, while L₂ is related to R₃. M₂ is not represented as it is not related to any reasoning rules. The firing strength of each rule is calculated in layer 3 by the related inference operation in Equation (3). After normalization in layer 4 and defuzzification (e.g., centroid), the output indicator value y can be computed in layer 5 using Equation (4).