Vibration Signal Classification Using Stochastic Configuration Networks Ensemble

Abstract

For vibration signals, this paper proposes an ensemble classification method based on stochastic configuration networks (SCNs). Firstly, the time–frequency analysis methods are used to obtain the frequency spectrum signal and time–frequency images. The sample data in the frequency domain and the time–frequency domain can characterize fault information from different perspectives. The hybrid data that consist of the sample data from the two domains are used to build a SCN model. Moreover, a SCNs ensemble method is proposed to solve the fault classification problem, and the sub-classifiers are built to extract fault features from different training data. In the experiment, the bearing and gear fault datasets are used for performance comparison. The experimental results show that the proposed SCNs ensemble model obtains good classification results, and compared with the deep learning methods, the SCN modeling process is more simple and effective for industrial data classification.

1. Introduction

In the industry process, the bearing and gears are important parts of the rotating machinery, and the failure of them may cause production breakdown and economic losses. Therefore, detecting the anomaly and diagnosis fault severity is worth studying, and is of great significance to ensure the safe operation and economic maintenance of machinery equipment [1]. In the fault diagnosis, the analysis of vibration signals plays an important role. For the time-series monitor signals, several features such as peak, mean, variance and root mean square are extracted for fault analysis [2]. The time-series signals are also transformed to the frequency domain and time–frequency domain by time–frequency analysis methods to obtain various features and identify fault severity [3,4,5,6].

In recent years, due to the strong representation learning ability, deep learning methods have been widely used for fault diagnosis [7,8,9]. Lu et al. [10] split the vibration signal into a series of time sub-series samples by continuous interleved sampling, and fault feature maps were used to build a convolutional neural network (CNN) for fault diagnosis. Liu et al. [11] proposed an optimized network structure to describe the correlation between signals at different time intervals, and the diagnosis performance was improved under non-stationary conditions. Huang et al. [12] proposed a multi-scale cascade CNN to extract more distinguishable fault features. Xu et al. [13] proposed an online fault diagnosis method based on a deep transfer CNN framework, which was made up of an online CNN based on LeNet-5 and several offline CNNs with a shallow structure. Zhang et al. [14] designed an adaptive activation function with a slope and threshold of the tanh function and proposed a deep adaptive network based on ResNet and STAC-tanh for fault diagnosis. Guan et al. [15] proposed a multi-sensor and multi-scale model to bring a new perspective to accurate fault diagnosis. For time–frequency image data, Zhang et al. [16] utilized the SELU function and hierarchical regularization to build a CNN network. He et al. built [17] a large memory storage retrieval neural network on the spectrum matrix data obtained through short-time Fourier transform. Gltekin et al. [18] proposed a multi-sensory data fusion diagnosis method based on ResNets to deal with the time–frequency images. Wang et al. [19] proposed a multi-view feature selection with information complementarity and consensus to efficiently select relevant features for fault diagnosis. For fault diagnosis, deep learning-based methods can obtain good recognition performance. However, the learning process requires a large number of parameters and computing resource, and it is sensitive to parameters, such as initial weights, learning rate, etc.

To overcome the aforementioned issues above, random neural networks (RNNs) have been presented, in which the weight parameters are stochastically configured [20]. Schmidt et al. [21] proposed a feed-forward neural network with random weights (NNRW) based on the randomization technique. Pao et al. [22,23,24] proposed a random vector functional link (RVFL) neural network that uses a direct link to connect the input layer to the output layer, and the weights and biases from the input layer to the hidden layer are generated randomly from a certain range. Wang and Li [25] proposed the stochastic configuration networks (SCNs), where the stochastic configuration learning process was performed under a supervisory mechanism that ensures the resulting SCN models hold the universal approximation property. A 2-D stochastic configuration network (2DSCN) [26] was developed for matrix inputs, and the experimental results showed its good potential for image data analytics. Wang and Felicetti [27,28] proposed a framework of stochastic configuration machines (SCMs) by composing a mechanism and a DeepSCN model and implemented on FPGAs.

Due to the parameter randomness, RNN-based ensemble learning has been proposed in order to improve the accuracy and stability of the models. Alhamdoosh and Wang [29] employed the RVFL networks as base components and incorporated with the negative correlation learning strategy for building neural network ensembles. Wang and Cui [30] proposed a fast decorrelated neuro-ensemble with heterogeneous features for large-scale data analytics, where the SCNs are employed as base learner models and the negative correlation learning strategy is adopted for weights evaluation. Wang and Li [31] proposed a SCN model with a deep network structure, which realizes the layer-by-layer approximation of the objective function by stacking the hidden features freely. Huang et al. [32] proposed an ensemble model with the base models, selecting from a set of SCN-based learners, and it has been used for large-scale and/or online stream data modeling. Meanwhile, for the fault diagnosis problem, Liu et al. [33] built a SCN model to classify the types of fault by using the fault features extracted from the vibration signals. Li et al. [34] adopted a self-attention long short-term memory (LSTM) network and self-attention residual network to extract fault features, then a SCN-based method was built with these fault features for bearing fault classification. Although experimental results have demonstrated the advantages of SCN-based models for application in fault diagnosis, the recognition performance is strongly dependent on the early feature extraction methods.

This paper proposes a SCNs ensemble model, which aims to combine different fault characters extracted from multiple source signals for the classification task. The proposed model makes use of the fault vibration information in the frequency domain and the time–frequency domain; the extracted features are fused in different ways to improve the classification effect. The ensemble algorithm randomly initializes the hidden layers parameters in the base SCNs, and the global output weight is calculated by employing the least square method with the $L_1$ norm constraint, which is easy and simple to implement. The experimental results show that the proposed SCNs ensemble model outperforms the compared stochastic models and obtains better classification performance for vibration fault signal.

The remainder of this paper is organized as follows. Section 2 overviews the stochastic configuration networks, including the SCN framework and 2DSCN with image inputs. Section 3 details the classification model based on SCN with hybrid data and the proposed ensemble SCNs with algorithmic descriptions. Section 4 presents the experimental study on industry fault dataset. Finally, the conclusion is presented in Section 5.

2. Stochastic Configuration Networks

As a feedforward neural network, SCNs [25] introduce a supervision mechanism to configure the weights of new nodes in the hidden layer, and the stochastic configuration algorithm can ensure the universal approximation ability of the built model. The SCN with a single hidden layer is shown in Figure 1. Given the input data $x\in R^m$, then the modeling process of the SCN framework can be described as follows.

Given a target function $f:R^d\to R^m$, it is assumed that we have already built a SCN model with $L-1$ hidden nodes. The output is

$$\begin{array}{c}\hfill f_{L-1}\left(x\right)=\sum _{l=1}^{L-1}{\beta }_l{g}_l(w_l^{T}x+b_l),L=1,2,...(f_0=0)\end{array}$$

(1)

where $w_l\in R^d$ is the weight parameter, $b_l\in R$ is the bias, ${\beta }_l=[{\beta }_{l,1},{\beta }_{l,2},...,{\beta }_{l,m}]$ is the weight of the output layer, and g is the activation function. Then, the residual error is calculated

$$\begin{array}{c}\hfill e_{L-1}=f-f_{L-1}=[e_{L-1,1},...,e_{L-1,m}].\end{array}$$

(2)

If the error does not reach the stop condition, a new node should be added, and the new weights $w_L,b_L$ are configured to calculate the hidden output

$$\begin{array}{c}\hfill h_L\left(x\right)=g_L(w_L^{T}x+b_L).\end{array}$$

(3)

Denote a set of variables ${\xi }_{L,q},q=1,2,...,m$ as follows:

$$\begin{array}{c}\hfill {\xi }_{L,q}=\frac{{(e_{L-1,q}{\left(x\right)}^T·h_L\left(x\right))}^2}{h_L{\left(x\right)}^T·h_L\left(x\right)}-(1-r-{\mu }_L)e_{L-1,q}{\left(x\right)}^T{e}_{L-1,q}\left(x\right),\end{array}$$

(4)

where $0<r<1$, ${\mu }_L$ is a real sequence with $0<{\mu }_L\le 1-r,{lim}_{L\to \infty }{\mu }_L=0$. Based on the the universal approximation property of SCNs in [25], the SCN model is built under the constraint condition

$$\begin{array}{c}\hfill {\xi }_{L,q}\ge 0,q=1,2,...,m.\end{array}$$

(5)

Besides, ${\beta }_L$ is calculated by

$$\begin{array}{c}\hfill {\beta }_{L,q}=\frac{e_{L-1,q}{\left(x\right)}^T·h_L\left(x\right)}{h_L{\left(x\right)}^T·h_L\left(x\right)},q=1,2,...,m,\end{array}$$

(6)

and the current output is

$$\begin{array}{c}\hfill f_L=f_{L-1}+{\beta }_L{g}_L(w_L^{T}x+b_L).\end{array}$$

(7)

In the stochastic configure learning algorithm, the hidden layer weights $w_l,l=1,2,...,L$ are firstly taken from a certain distribution (e.g., uniform distribution or Gaussian distribution), and the bias $b_l$ can be calculated by

$$\begin{array}{c}\hfill b_l=-w_l^T{x}^{★},l=1,2,...,L,\end{array}$$

(8)

where $x^{★}$ is randomly taken from the training dataset [35]. Then, the supervision mechanism (5) is employed to select proper weight values and add new hidden nodes. The output weight $\beta$ can also be calculated by solving the following least square problem

$$\begin{array}{c}\hfill {\beta }^{★}=[{\beta }_1^{★},{\beta }_2^{★},...,{\beta }_L^{★}]=\arg \underset{\beta }{\min }\left|\right|f-\sum _{l=1}^L{\beta }_l{h}_l{\left|\right|}_2^2.\end{array}$$

(9)

Similarly, for the 2DSCN model, i.e., the input is matrix data $x\in R^{d1\times d2}$, the target function is $f:R^{d1\times d2}\to R^m$. The 2DSCN model is also built under the supervised mechanism (5) with the configured parameters, and the output of the hidden node is

$$\begin{array}{c}\hfill h_l\left(x\right)=g_l(u_l^{T}x{v}_l+b_l),l=1,2,...,L,\end{array}$$

(10)

where $u_l\in R^{d1}$, $v_l\in R^{d2}$ are the hidden layer weights, $b_l$ is the bias, and ${\beta }_l$ is the output weight. Then, the model output is

$$\begin{array}{c}\hfill f_L\left(x\right)=\sum _{l=1}^L{\beta }_l{h}_l.\end{array}$$

(11)

Like $w_l,b_l$ in (7), the weights $u_l,v_l$ are randomly assigned and the bias is calculated via $b_l=-u_l^T{x}^{★}{v}_l$ with randomly sampled data $x^{★}$. After successfully adding L hidden nodes, the weight $\beta$ can be estimated by (7) or another two classical regression models:

$$\begin{array}{c}\hfill \mathrm{Ridge}:\arg \underset{\beta }{\min }\left|\right|f-\sum _{l=1}^L{\beta }_l{h}_l{\left|\right|}_2^2+{\alpha \left|\right|\beta \left|\right|}_2^2,\end{array}$$

(12)

$$\begin{array}{c}\hfill \mathrm{Lasso}:\arg \underset{\beta }{\min }\left|\right|f-\sum _{l=1}^L{\beta }_l{h}_l{\left|\right|}_2^2+{\alpha \left|\right|\beta \left|\right|}_1.\end{array}$$

(13)

3. Fault Diagnosis Based on Ensemble SCNs

In fault diagnosis, the monitor data are a time-series vibration signal. For different operating states, the collected signals have different characters for fault classification. In addition, the time-series signals can be transformed to frequency spectrum and time–frequency images. In this section, we firstly combine the frequency spectrum and time–frequency image via vectorization, and a SCN model is built on the hybrid data in Section 3.1. Then, the ensemble SCNs model is proposed to improve the recognition performance and described in Section 3.2.

3.1. SCN Model with Hybrid Data

As shown in Figure 2, the monitor vibration signal is sampled by a sliding window with a certain size, then the time–frequency analysis methods such as Fourier transform and short time Fourier transform (STFT) are employed to analyze the sample signal and obtain the frequency spectrum from the frequency domain and the time–frequency image from the time–frequency domain, respectively. Fault data in the frequency domain and the time–frequency domain describe the fault features from different perspectives. The hybrid data that consist of samples from these two domains are used to build a SCN model in order to achieve better classification results.

Given a dataset $\{\mathbf{X},\mathbf{D},\mathbf{T}\}$ that consists of time–frequency image $\mathbf{X}$, the frequency spectrum signal is $\mathbf{D}$ and the target label is $\mathbf{T}$. In order to combine the samples from these two domains, the 2D images in $\mathbf{X}$ are vectorized to one-dimensional data denoted as $\mathbf{A}$, i.e.,

$$\begin{array}{c}\hfill \mathbf{A}=Vec\left(\mathbf{X}\right).\end{array}$$

(14)

The hybrid data $\mathbf{Z}=[\mathbf{D},\mathbf{A}]$ are obtained and will be used to build the SCN model. Because the hidden parameters $w_l,b_l$ are randomly configured under the constraint condition (5), the hidden layer output can be evaluated by

$$\begin{array}{c}\hfill h_l=g(w_l^T\mathbf{Z}+b_l).\end{array}$$

(15)

The output weight $\beta$ can be estimated by solving the following optimization problem:

$$\begin{array}{c}\hfill \mathbf{E}\left(\beta \right)=\underset{\beta }{\min }\left|\right|\mathbf{H}\beta -{\mathbf{T}\left|\right|}_2^2+{\alpha \left|\right|\beta \left|\right|}_1.\end{array}$$

(16)

where $\mathbf{H}=[h_1,h_2,...,h_L]$ is a non-linearly transformed feature matrix, $\mathbf{T}$ is the target label, and $\alpha$ is the regularization parameter. The detailed modeling process of the SCN with hybrid data is described in Algorithm 1.

3.2. SCNs Ensemble

In order to improve the classification effect, we propose an ensemble method based on SCNs. The time–frequency image has been used to build the model, but the vectorization operation damages the image structure and cause a loss of information; the image data can be directly used via 2DSCN modeling. As shown in Figure 3, the frequency spectrum, time–frequency images and the hybrid data are used to build sub-learners based on SCNs, respectively. And the ensemble learning is applied to combine the SCN learners and obtain the final classification result.

Algorithm 1: SCN with hybrid data

The SCNs ensemble learning process is described as follows:

(1) Data pre-processing.

Given the dataset $\{\mathbf{X},\mathbf{D},\mathbf{Z},\mathbf{T}\}$ with N samples, where $\mathbf{X}=\{x_1,x_2,...,x_N\}$, $\mathbf{D}=\{D_1,D_2,...,D_N\}$, $\mathbf{Z}=\{z_1,z_2,...,z_N\}$ and target label $\mathbf{T}=\{t_1,t_2,...,t_N\}$, all sample data are normalized to $[-1,1]$.

(2) Select the base model.

Because the samples from the training dataset have different dimensions, i.e., $D_i\in R^{d1}$, $Z_i\in R^d$, and $x_i\in R^{d2\times d3}$, then two 1D-SCN learners and a 2D-SCN learner will be built on the datasets $\mathbf{D}$, $\mathbf{Z}$ and $\mathbf{X}$, respectively.

(3) Building the SCN learners.

• SCN-D:
  Randomly assign $w{1}_L$ from ${[-\lambda ,\lambda ]}^{d1}$, and calculate $b{1}_L=-w{1}_L^T{D}^{★}$; calculate $h{1}_L$ by Equation (3) and ${\xi }_{L,q}^1$ Equation (4); then select the proper weights under the supervision mechanism (5); find $w{1}_L^{★},b{1}_L^{★}$ maximizing ${\xi }_L^{\left(1\right)}$; and set the hidden output matrix ${\mathbf{H}}_{\mathbf{1}}=[h{1}_1^{★},h{1}_2^{★},...,h{1}_L^{★}]$.
• SCN-X:
  Randomly assign $u_L,v_L$ from ${[-\lambda ,\lambda ]}^{d2}$, ${[-\lambda ,\lambda ]}^{d3}$, respectively, and calculate $b{2}_L=-u_L^T{X}^{★}{v}_L$; calculate $h{2}_L$ by Equation (10) and ${\xi }_{L,q}^2$ Equation (4); then select the proper weights under the supervision mechanism (5); find $u_L^{★},v_L^{★},b{2}_L^{★}$ maximizing ${\xi }_L^{\left(2\right)}$; and set the hidden output matrix ${\mathbf{H}}_{\mathbf{2}}=[h{2}_1^{★},h{2}_2^{★},...,h{2}_L^{★}]$.
• SCN-H:
  Randomly assign $w{3}_L$ from ${[-\lambda ,\lambda ]}^d$, and calculate $b{3}_L=-w{3}_L^T{Z}^{★}$; calculate $h{3}_L$ by Equation (15) and ${\xi }_{L,q}^3$ Equation (4); then select the proper weights under the supervision mechanism (5); find $w{3}_L^{★},b{3}_L^{★}$ maximizing ${\xi }_L^{\left(3\right)}$; and set the hidden output matrix ${\mathbf{H}}_{\mathbf{3}}=[h{3}_1^{★},h{3}_2^{★},...,h{3}_L^{★}]$.

(4) Ensemble learning.

The hidden feature matrices of the model SCN-D, SCN-X and SCN-H are ${\mathbf{H}}_{\mathbf{1}},{\mathbf{H}}_{\mathbf{2}}$, and ${\mathbf{H}}_{\mathbf{3}}$, respectively. Then, concatenate the hidden feature matrix $\tilde{\mathbf{H}}=[{\mathbf{H}}_{\mathbf{1}},{\mathbf{H}}_{\mathbf{2}},{\mathbf{H}}_{\mathbf{3}}]$, and the corresponding parameter $\beta$ is calculated by

$$\begin{array}{c}\hfill {\beta }^{★}=\arg \underset{\beta }{\min }\left|\right|\tilde{\mathbf{H}}\beta -{T\left|\right|}_2^2+{\alpha \left|\right|\beta \left|\right|}_1.\end{array}$$

(17)

The output is obtained $O_{escn}=\tilde{\mathbf{H}}{\beta }^{★}$.

(5) Calculate the classification error.

The residual error is calculated via $e_L=\left|\right|O_{escn}-T{\left|\right|}_F$, then it is used to configure the weights of new hidden nodes by the supervised constraint. The SCNs ensemble model is built incrementally until the tolerance error $ϵ$ is reached or the number of hidden nodes L equals to $L_{max}$. Finally, the output $O_{escn}$ is normalized to $[0,1]$ to predict the sample classes and obtain the resultant classification labels for fault identification.

In the proposed ensemble method, the SCN learners (i.e., SCN-D, SCN-X and SCN-H) are built on different training datasets, including frequency spectrum data, time–frequency images, and their hybrid data, respectively. The pseudo code of the SCNs ensemble for fault recognition in this section is described in Algorithm 2. The goal of the ensemble learning is to combine the various features extracted from the sample data in different domains via the SCN based sub-learners for fault analysis. Because the stochastic configuration algorithm is incremental learning, the SCN model is built by adding new hidden nodes gradually. So in the ensemble learning process, the SCN learners are modeled synchronously and have the same number of hidden nodes with the weight $\beta$, and the error is calculated with the configured parameters. In addition, the SCN model can also be built separately to obtain the optimal sub-learners, and then the global weight $\beta$ is calculated, and the classification results are output.

Algorithm 2: SCNs ensemble

4. Performance Evaluation

4.1. Experimental Setup

In this section, the vibration data are used for experimental comparison. The original collected bearing data are time–series vibration signals, and they are sampled via a sliding window with a fixed size. In this experiment, the window size is set to 1024 and used to obtain learning samples, then the Fourier transform and STFT are carried out to obtain samples of the frequency domain and time–frequency domain. The size of the frequency spectrum is 512, and that of the time–frequency image is $33\times 33$. As shown in Figure 4, the samples of different fault modes in multiple domains are displayed. We can find that the signal of the normal sample is low frequency, while the samples of different fault locations have more high–frequency signals, and there are differences among them.

We first evaluate the classification results with samples from different domains, and the dataset provided by the Bearing Data Center at Case Western Reserve University (CWRU) [36] is used for comparison. The bearing data are collected from the drive end of the electrical machining with 1797 r/min rotating speed and 12 KHz the sampling frequency. There are four modes in the CWRU dataset including normal, inner ring faults, outer ring faults, and rolling element faults. As shown in

Table 1. The description of the CWRU dataset.

Damage Size	Samples	Fault Mode	Label
∼	238	Normal	0
0.007 in.	118	Inner ring	1
0.014 in.	119	Inner ring	2
0.021 in.	119	Inner ring	3
0.007 in.	118	Rolling element	4
0.014 in.	118	Rolling element	5
0.021 in.	118	Rolling element	6
0.007 in.	119	Outer ring	7
0.014 in.	119	Outer ring	8
0.021 in.	119	Outer ring	9

, because of the different bearing diameters, the dataset has ten different classes in total, including normal condition and nine different severity faults. In the learning process, the samples are randomly selected, with $80\%$ as the training dataset and the remaining $20\%$ as the testing dataset. For SCN and 2DSCN, we take constructive sequence $r=\{0.9,0.99,0.999,0.9999,0.99999\}$, $\lambda =\{0.5,1,5,30,50,100\}$, training tolerance error $ϵ=0.00001$, maximum number of candidate nodes $T_{max}=100$, and g is the sigmoid activation function.

For the CWRU dataset, the samples from the time domain, frequency domain, and time–frequency domain are used to build the SCN models, respectively. The recognition rates of the SCN models in each domain are shown in Figure 5. The results show that the recognition rate increases with the increase in the number of hidden nodes L; in particular, the SCN model built with the frequency-domain samples obtains high testing accuracy with fewer nodes, followed by the SCN model built with the time–frequency domain samples. However, the SCN model built with time-domain samples has a lower recognition rate at the same number of hidden nodes L. The result demonstrates that the SCN model built by using samples in the frequency domain and the time–frequency domain has advantages in the fault data classification task.

4.2. Results and Discussion

In the experiments, the vibration data provided by the Jiangnan University (JNU) [37], the Southeast University (SEU) [38] and the University of Connecticut (UoC) [39] are used for performance comparison. The JNU dataset is collected under different rotating speeds, and there are four operating modes for each speed. The JNU dataset has twelve categories with a total of 8790 samples. The SEU dataset is also collected under different rotating speeds and load conditions, and has twenty categories with a total of 2040 samples. Similarly, the UoC dataset has nine categories with a total of 3238 samples. Then, the corresponding frequency spectrum data $(1\times 512)$ and time–frequency images $(33\times 33)$ are obtained via Fourier transform and STFT.

For each dataset, the samples are randomly selected, with $80\%$ as the training dataset and the remaining $20\%$ as the testing dataset. In the algorithm implementation, the weights in NNRW and NNRW2D are randomly assigned from ${[-1,1]}^{512}$ and ${[-1,1]}^{33}$, respectively, while the biases for them are randomly assigned from $[-1,1]$. For the SCNs, the parameters $\lambda ,T_{max}$ and r are the same as those set on the CWRU dataset.

In the stochastic configuration algorithm, the output weight parameter $\beta$ is calculated via the optimal model, i.e., Equation (16). For the regularization factor $\alpha \in [0,1]$, first we take $\alpha =\{0:0.2:1\}$ with other parameters fixed. The difference in the classification rate under different $\alpha$ values is small. As shown in Figure 6, $\alpha$ is reset to some smaller values $\{0.0001,0.001,0.005,0.01,0.05,0.08\}$. For the JNU dataset, the optimal model is insensitive to the factor $\alpha$ and obtains close values, which indicates that the parameter $\beta$ itself calculated by the stochastic configuration algorithm is sparse and the regular term has a weak effect. For the SEU and UoC dataset, there is no obvious trend in the recognition rate with different regularization factor values. According to the comparison results, $\alpha$ is set to 0.05 in the following discussion.

To show the results of the visual comparison, set the maximum number of hidden modes $L_{max}=\{100:100:1400\}$ for the JNU dataset and $L_{max}=\{20:20:240\}$ for the SEU dataset, and the other parameters are fixed. For the randomized algorithms, the SCN-D and NNRW are built with frequency spectrum signal $\mathbf{D}$, the SCN-X and NNRW2D are built with time–frequency image data $\mathbf{X}$, and the SCN-H is built with hybrid data $\mathbf{Z}$. As shown in Figure 7 and Figure 8, the recognition rates of the comparison models increase with the increase in the number of hidden layer nodes L. The results show that the SCN-H model built with the hybrid data obtains the highest accuracy values. Meanwhile, the SCN-D and SCN-X methods obtain higher accuracy than the NNRW and NNRW2D methods under the same training data, respectively. Compared with SCN-X, the SCN-D can be built with fewer hidden nodes to obtain the same recognition rate, and more fault features can be extracted from the frequency spectrum data.

To demonstrate the effectiveness of the proposed model, for the SCN-based models, we set the parameter $L_{max}=5000$, $T_{max}=100$, $r=\{0.9,0.99,0.999,0.9999,0.99999\}$, $\lambda =\{0.5,1,5,30,50,100\}$, $ϵ=0.00001$. For the NNRW and NNRW2D models, the weights and bias are randomly configured from $[-1,1]$. The comparison models are fully trained with the sigmoid activation function, and 30 independent trials are performed on each dataset. As shown in

Table 2. Performance comparison with fault dataset.

Dataset	Model	Accuracy	Precision	Recall
JNU	NNRW	0.9338	0.8775	0.9887
	NNRW2D	0.8741	0.7673	0.9756
	SCN	0.9558	0.9182	0.9929
	SCN2D	0.9200	0.8501	0.9883
	SCN-H	0.9660	0.9372	0.9945
SEU	NNRW	0.9490	0.9034	0.9941
	NNRW2D	0.9027	0.8154	0.9879
	SCN	0.9786	0.9595	0.9976
	SCN2D	0.9682	0.9397	0.9965
	SCN-H	0.9854	0.9723	0.9984
UoC	NNRW	0.9517	0.9143	0.9882
	NNRW2D	0.6740	0.4189	0.8553
	SCN	0.9519	0.9148	0.9881
	SCN2D	0.7147	0.4902	0.8896
	SCN-H	0.9582	0.9261	0.9897

, the indexes accuracy, precision and recall score are calculated. The SCN-H model has the highest recognition rate, followed by the SCN-, NNRW- and SCN2D-based models, and the NNRW2D-based model obtains the lowest accuracy. The experimental results show the SCN-based models are superior to the NNRW-based models on the training samples with same data dimension. And the SCN model built with the hybrid data has learned better fault representation on each dataset.

We also evaluate the effectiveness and advantages of the proposed ensemble SCNs on the JNU, SEU and UoC datasets with the existing ensemble models: DNNE [29], SCNE [30], RNNE-RVFL and RNNE-SCN [32]. For the SCNs ensemble algorithm, the average, voting and negative correlation learning (NCL) [40] strategies are used for ensemble learning. As shown in

Table 3. Performance comparison on ensemble models.

Model	JNU			SEU			UoC
	Accuracy	Precision	Recall	Accuracy	Precision	Recall	Accuracy	Precision	Recall
DNNE	0.9466	0.9013	0.9911	0.9571	0.9186	0.9953	0.9566	0.9233	0.9893
SCNE	0.9570	0.9203	0.9933	0.9826	0.9670	0.9981	0.9571	0.9241	0.9894
RNNE-RVFL	0.9573	0.9212	0.9930	0.9863	0.9739	0.9986	0.9599	0.9289	0.9903
RNNE-SCN	0.9659	0.9366	0.9948	0.9963	0.9930	0.9996	0.9638	0.9360	0.9912
SCN-Ensemble (average)	0.9722	0.9485	0.9958	0.9937	0.9881	0.9993	0.9575	0.9246	0.9897
SCN-Ensemble (voting)	0.9685	0.9415	0.9952	0.9834	0.9686	0.9981	0.9630	0.9345	0.9910
SCN-Ensemble (NCL)	0.9726	0.9492	0.9960	0.9975	0.9954	0.9997	0.9621	0.9327	0.9909

, the SCN ensemble models with NCL strategy obtain higher values on JNU and SEU dataset, and are comparable on the UoC dataset. The evaluation results show that the SCNs ensemble model with sub-learners built on multiple source training data obtains comparable fault classification results. Moreover, for the SCN-ensemble methods, due to the proposed method only having three sub-learners, the average and NCL strategies obtain higher resulted values than the voting strategy.

4.3. Comparison with Deep Learning Models

In our experimental study, the proposed method is compared with some classic deep learning models, including multi-layer perceptron (MLP) [41], CNN [42], denoising auto-encoder (DAE) [43], AlexNet [44], ResNet18 [45] and long short-term memory network (LSTM) [46].

Table 4. Performance comparison with deep learning methods.

Model	CWRU	JNU	SEU	UoC
MLP	1.000	0.9488	0.9290	0.6598
CNN	1.000	0.9352	0.9669	0.6332
DAE	1.000	0.9446	0.9718	0.8417
AlexNet	1.000	0.9579	0.9731	0.6722
ResNet18	1.000	0.9548	0.9804	0.7969
LSTM	1.000	0.9564	0.9650	0.8174
SCN-H	1.000	0.9660	0.9854	0.9582
SCN-Ensemble	1.000	0.9726	0.9975	0.9621

shows the recognition results of the comparison methods. It can be seen that all the methods can achieve $100\%$ accuracy on the CWRU dataset because of its low data complexity. For the JNU and SEU datasets, the SCN-H and SCN-Ensemble methods obtain comparable recognition rates. In particular, the proposed SCNs-based method outperforms the compared methods on the UoC dataset.

5. Conclusions

This paper proposes a classification method based on SCNs ensemble, and the sample data in different domains are analyzed and used to build SCNs-based classifiers. Due to the stochastic configuration mechanism for the random weights and bias in the modeling process, the SCN models obtain better classification results than the NNRW models. The experimental results show that the proposed SCNs ensemble method outperforms other randomized methods because of the application of multiple domain sample data, and obtains good classification results. Compared with deep learning methods, the proposed method has comparable recognition performance, and the algorithm implementation is simple and easy, which demonstrates great potential in the field of industrial informatics. For future works, the deep SCNs can be considered the base classifier, and various hybrid data are analyzed to characterize the fault information.