# Multiclass Incremental Learning for Fault Diagnosis in Induction Motors Using Fine-Tuning with a Memory of Exemplars and Nearest Centroid Classifier

Authors: Magdiel Jiménez-Guarneros; Jonas Grande-Barreto; Jose de Jesus Rangel-Magdaleno
Journal: Shock and Vibration
 (2021)

---

## Abstract

Early detection of fault events through electromechanical systems operation is one of the most attractive and critical data challenges in modern industry. Although these electromechanical systems tend to experiment with typical faults, a common event is that unexpected and unknown faults can be presented during operation. However, current models for automatic detection can learn new faults at the cost of forgetting concepts previously learned. This article presents a multiclass incremental learning (MCIL) framework based on 1D convolutional neural network (CNN) for fault detection in induction motors. The presented framework tackles the forgetting problem by storing a representative exemplar set from past data (known faults) in memory. Then, the 1D CNN is fine-tuned over the selected exemplar set and data from new faults. Test samples are classified using nearest centroid classifier (NCC) in the feature space from 1D CNN. The proposed framework was evaluated and validated over two public datasets for fault detection in induction motors (IMs): asynchronous motor common fault (AMCF) and Case Western Reserve University (CWRU). Experimental results reveal the proposed framework as an effective solution to incorporate and detect new induction motor faults to already known, with a high accuracy performance across different incremental phases.


---

## Body

## 1. Introduction

IMs support most of the production process in the modern industry’s daily life due to their straightforward construction, reliability, and relatively low cost. However, IMs operate for long uninterrupted working periods, are exposed to the elements, and minimum preventive maintenance. These operative conditions raise unexpected faults that can show up at any time, causing lower productivity and economic losses. Thus, early motor failure detection and correction are challenging problems that catch many researchers’ attention.From a general overview, motor fault analysis methods split into signal processing and artificial intelligence approaches [1]. The first ones have been focused on analyzing diverse physical magnitudes to find features that help identify abnormal behavior in the motor’s performance [2, 3]. For example, rotor vibrations [4], bearing faults [5], and broken rotor bar [2]. Meanwhile, artificial intelligence-based methods have been integrated to provide automatic fault detection using a data-driven approach. These methods base their performance on extracted features from raw signals to be used as inputs. In past years, deep learning (DL) architectures, such as autoencoders (AE) [6], convolutional neural network (CNN) [5, 7, 8], and capsule networks (CapsNet) [1], have been used in fault diagnosis due to their potential applicability for the automatic feature extraction, reported in several cases new state-of-the-art results. In the literature, most works combine DL architectures with different handcraft features and feature extractors (e.g., Fourier and Wavelet transform) [8]. Recently, some authors [9–12] have shown some promising advances to eliminate the requirement of the handcraft features, where CNN architectures have demonstrated high effectiveness. Despite this progress, classification models have been focused on detecting a set of known patterns that characterize typical faults on equipment from manufacturers. However, modifications in the operative conditions can generate patterns from new failures that differ from those detected by the current model. This issue forces existing methods to learn a new model considering unknown failure conditions.To overcome the practical challenge mentioned above, multiclass incremental learning (MCIL) arises a promising solution by updating the current model on new data instead of training once on a whole dataset. Indeed, MCIL aims to learn new classes from previous ones, although none or a few samples of old classes are retained. Unlike the conventional classification setting, in MCIL, samples from different classes come in different time phases, whereas incremental classifiers aim to achieve a competitive performance overall seen classes [13]. Motivated by this, only a few works have been reported by traditional approaches to address multiclass incremental learning. For example, Saucedo-Dorantes et al. [14] trained a self-organizing map (SOM) every time that a new detection occurs. However, this model does not retain samples from previous classes, and the complexity of the model increases when new faults are incorporated. Incremental model transfer learning (IMTL) [15] follows a domain adaptation approach to allow a classification model to detect new faults but requires all samples from past faults during the subsequent incremental phases to achieve high performance. Overall, these works are still limited because they depend on an engineered data representation. In this direction, deep learning approaches have certain advantages by learning task-specific features and classifiers from raw signals. However, deep learning models can suffer from catastrophic forgetting [16] when they are trained incrementally, i.e., the tendency of a neural network to underfit past classes when new ones are learned.This study presents an MCIL framework based on an 1D CNN for fault detection in IMs. To tackle the catastrophic forgetting problem, the presented framework employs a memory containing representative exemplars from past data and updates a 1D CNN model across incremental states, using a fine-tuning procedure [16]. The representative exemplars from past (known) faults are selected using the Herding method [17]. Next, nearest centroid classifier (NCC) is used to classify test samples in each incremental phase. By doing this, the proposed framework maintains a constant model complexity while new classes appear each time. We evaluated and validated the presented model over two different study cases: (1) motor common faults diagnosis and (2) bearing fault diagnostics. Experimental results show that the proposed MCIL framework effectively incorporates new faults on an 1D CNN, achieving a high accuracy performance across different incremental phases.


## 2. Convolutional Neural Network

Convolutional neural network (CNN) is a biologically inspired artificial neural network that processes data with a known grid-like topology [18]. CNN alternates convolution and pooling layers, followed by a fully connected layer to extract features and generate the desired output. Due to the inherent one-dimensional signals obtained from a vibration analysis in IMs, it has been preferable to deal with these signals using one-dimensional models [9, 11]. Thus, we first describe 1D convolution operators, which are used in the presented work. Then, we describe the complement layers that integrate a convolutional network.In its standard approach, CNN performs a set of convolutions between an input signal and some finite impulse response (FIR) filters. The convolution operation (∗) is described as a weighted average of an input signal xi:(1)si=ki∗xi=∑j=0L−1ki−j⋅xj,where si is called i-th feature map and k denotes a weighting factor, called filter or kernel, with length L. The kernels are built to identify spatial features on the input data. The output from a convolutional layer defines the next layer’s activation value. Then, the output sil of a convolutional layer l at i-th feature map is defined as follows:(2)sil=σ∑j=1LKi,jl∗xjl−1+bil,where Ki,jl denotes each local weighting factor of the kernel, xjl−1 represents the j-th feature map at the layer l−1, L is the number of filters applied over xjl−1, bil is the bias, and σ is the activation function.Most of the time, raw data contain noise and undesirable spectral shapes that affect the feature extraction process [19]. Motivated from this issue, the SincNet layer [9, 20], an extension of the standard convolution, applies a set of temporal convolutions between a raw signal and digital filters to boost the first convolutional layer output.


### 2.1. Sinc Convolution

Instead of learning the filters from the data, as the conventional CNN, the SincNet [9, 20] performs the convolution operation with a preset function g that requires only a reduced set of learnable parameters Θs, as defined in the following equation:(3)yn=xn∗gn,Θs,where g is a filter bank for band-pass filter in the frequency domain; it takes advantage of the Sinc function to convert to time domain through the inverse Fourier transform [19]. The use of rectangular filters represents a practical selection to define g. The magnitude Φ of a generic band-pass filter can be described as the difference between two low-pass filters.(4)Φf,fL,fH=rectf2fH−rectf2fL,where Θs=fL,fH the set of the trainable parameters; fL and fH represent low and high cutoff frequencies, respectively, of the band-pass filter learned by the Sinc filters. rect⋅ describes the rectangular function at the instant t as follows:(5)rectt=1,t≤0.5,0,otherwise.Using the inverse Fourier transform, the reference functiong becomes(6)gn,fL,fH=2fH⋅sinc2πfHn−2fL⋅sinc2πfLn,where the Sinc function is defined as sincx=sinx/x. Finally, to achieve an approximation of the ideal band-pass filter, a winnowing procedure is applied. This procedure multiplies the truncated function g with a window function ω [21], intending to smooth out the abrupt discontinuities at the ends of g:(7)gωn,fL,fH=gn,fL,fH⋅ωn,fL,fH.Therefore, the succeeding layers learn the filter gain of each actual layer.


### 2.2. Pooling Layers

These layers perform a downsampling to reduce the spatial size of features, encouraging the input data’s invariance to spatial translations. In particular, a max-pooling layer reporting thej-th maximum element within a rectangular frame for each feature map. Meanwhile, a global average pooling (GAP) layer replaces the fully connected layers in a CNN model [22], averaging the feature maps from previous convolutional layers. GAP aims to force correspondences between learned feature maps and classes in the previous convolutional layers.


## 2.1. Sinc Convolution

Instead of learning the filters from the data, as the conventional CNN, the SincNet [9, 20] performs the convolution operation with a preset function g that requires only a reduced set of learnable parameters Θs, as defined in the following equation:(3)yn=xn∗gn,Θs,where g is a filter bank for band-pass filter in the frequency domain; it takes advantage of the Sinc function to convert to time domain through the inverse Fourier transform [19]. The use of rectangular filters represents a practical selection to define g. The magnitude Φ of a generic band-pass filter can be described as the difference between two low-pass filters.(4)Φf,fL,fH=rectf2fH−rectf2fL,where Θs=fL,fH the set of the trainable parameters; fL and fH represent low and high cutoff frequencies, respectively, of the band-pass filter learned by the Sinc filters. rect⋅ describes the rectangular function at the instant t as follows:(5)rectt=1,t≤0.5,0,otherwise.Using the inverse Fourier transform, the reference functiong becomes(6)gn,fL,fH=2fH⋅sinc2πfHn−2fL⋅sinc2πfLn,where the Sinc function is defined as sincx=sinx/x. Finally, to achieve an approximation of the ideal band-pass filter, a winnowing procedure is applied. This procedure multiplies the truncated function g with a window function ω [21], intending to smooth out the abrupt discontinuities at the ends of g:(7)gωn,fL,fH=gn,fL,fH⋅ωn,fL,fH.Therefore, the succeeding layers learn the filter gain of each actual layer.


## 2.2. Pooling Layers

These layers perform a downsampling to reduce the spatial size of features, encouraging the input data’s invariance to spatial translations. In particular, a max-pooling layer reporting thej-th maximum element within a rectangular frame for each feature map. Meanwhile, a global average pooling (GAP) layer replaces the fully connected layers in a CNN model [22], averaging the feature maps from previous convolutional layers. GAP aims to force correspondences between learned feature maps and classes in the previous convolutional layers.


## 3. MCIL Methodology

LetX and Y denote a feature and a label space, respectively. Let D=X,Y=xj,yjj=1N be a labeled dataset with N samples, where X,Y∈X×Y. In a classification problem, a task T consists in learning a labeling function G, such that G:X⟶Y. Notice that G represents a deep neural network with parameters Θ, so that Y=GX;Θ. Likewise, G can be expressed as a composition of two functions, G=Gy∘Gf, where Gf:X⟶Z is a feature extractor and Gy:Z⟶Y feature labeling with parameters Θf and Θy, respectively; here, Z is a latent feature space. The feature extractor Gf takes X and produces a latent feature dataset Z. Then, Gy receives Z as input and produces label classifications Y, i.e., Y=GyGfX;Θf;Θy.We focus on multiclass incremental learning (MCIL) where the model complexity is maintained constant duringN incremental states, while a reduced number of samples is retained from past classes [13, 23]. We assume N+1 phases, that is, N incremental phases and one initial phase S0. A model G0 is learned on a dataset D0 during the phase S0. Due to this, we assume a memory limitation, all samples from D0 cannot be stored, so that exemplars E0 are selected and stored as a replacement of D0 with E0|≪|D0. In the i-th incremental phase, dataset Di from Ci classes is streamed, whereas exemplars E0:i−1 from phases 0 to i−1 are stored in memory. The aim of MCIL is to learn a model G using exemplars E0:i−1 and data set Di.Figure1 shows the flowchart of the MCIL methodology for fault detection in IMs. In the initial phase, a model G, that is 1D CNN, is trained via cross-entropy loss ℒce on the dataset D0, containing signals from different motor conditions. Next, exemplars E0 are selected using Herding method [17] over D0 in feature space, Z0=GfD0. The nearest centroid classifier (NCC) is used to classify test samples in the current phase using E0 as training set. In the i-th incremental phase, the output layer from the CNN is extended with randomly initialized weights for each new class. Then, the 1D CNN is fine-tuned over Di and E0:i−1 using cross-entropy loss ℒce; notice that imbalance data are produced in Di∪E0:i−1 because E0:i−1 contains a reduced set of exemplars from past classes. This procedure updates all parameters Θ of 1D CNN. The resulting trained model G in phase i is used to extract features from Di and E0:i−1. Herding method is used to select the exemplar set Ei over Di in feature space. Then, NCC uses E0:i as training set in feature space to classify test samples. This procedure is repeated over the different incremental phases.Figure 1
Flowchart of the presented methodology in order to train an incremental classifier for the fault detection in IMs.


### 3.1. CNN Architecture

The 1D CNN architecture is shown in Figure2. 1D time-domain signals are used as inputs to the 1D CNN. One Sinc layer [9, 20] and two standard convolution layers were incorporated into the feature extractor. Conv a×b−c denotes the convolution layer of c filters with a size a and a stride b. For the lower layers, large size filters were employed to deal with high frequencies present in data. We added max-pooling layers to reduce the spatial feature dimensions. Likewise, a global average pooling layer is used to reduce the spatial dimensions of the learned features. The output layer is extended for each new class with a random initial value. The softmax activation function is used at the output layer to perform motor fault classification.Figure 2
Architecture of the 1D CNN model.


### 3.2. Exemplar Set Selection

The exemplar setEi is adjusted in each incremental phase i using the Herding method [17], as shown in Algorithm 1. The exemplar selection is required when training data are available. Feature representation from dataset Di is obtained using the feature extractor Gf (line 2). Each sample is normalized employing the L2 norm (line 3). Notice that m exemplars are selected and stored iteratively for each class (lines 5–7). One sample is added to the exemplar set in each iteration, prioritizing that sample that makes the average feature vector better approximate the mean vector.Algorithm 1: Herding method.
Inputs:Xc=x1,…,xnc: dataset of class c; m: number of exemplars to select; Gf: feature extractorOutput:E: exemplar set(1)
InitializeE to the empty set {}(2)
Zc←GfXc \(⊳\) Get feature representations(3)
Z^c←Zc/Zc2 \(⊳\) L2 norm(4)
z¯←1/nc∑z^∈Z^cz^ \(⊳\) Get mean feature vector(5)
fork=1,…,mdo(6)
pk←argminz^∈Z^cz¯−1/kGfz^+∑j=1k−1Gfpj2(7)
end for(8)
E←p1,…,pmAlgorithm 2: Nearest centroid classifier.
Inputs:E0:i=p1,…,pt: exemplar set from phase 0 to i; Gf: feature extractor; xt: sample to be classifiedOutput:y∗: one hot vector of the class label; C: number of classes(1)
Z^←GfE0:i \(⊳\) Get feature representations(2)
forc=1,…,Cdo(3)
p¯c←argminp1∈Z^c∑p2∈Z^cdp1,p2(4)
end for(5)
y∗←argminc∈1,…,Cp¯c−Gfxt2 \(⊳\) nearest prototype


### 3.3. Nearest Centroid Classifier

Nearest centroid classifier (NCC) [24] is a nearest-neighbor classifier, which is used to address the bias produced on new classes by training CNN over imbalanced data. The procedure followed by NCC is described in Algorithm 2. First, feature representations from exemplars E0:i are obtained using the feature extractor Gf (line 1). The centroid is computed as the point from which the sum of the distances of all exemplars that belong to that particular class are minimized (lines 2–4). NCC assigns the label of the most similar class centroid to the test sample xt (line 5) as follows:(8)y∗=argminc∈1,…,Cdp¯c,Gfxt,where p¯c is the centroid vector for the class c, obtained from exemplars E0:i; meanwhile, d is the Euclidean distance.


## 3.1. CNN Architecture

The 1D CNN architecture is shown in Figure2. 1D time-domain signals are used as inputs to the 1D CNN. One Sinc layer [9, 20] and two standard convolution layers were incorporated into the feature extractor. Conv a×b−c denotes the convolution layer of c filters with a size a and a stride b. For the lower layers, large size filters were employed to deal with high frequencies present in data. We added max-pooling layers to reduce the spatial feature dimensions. Likewise, a global average pooling layer is used to reduce the spatial dimensions of the learned features. The output layer is extended for each new class with a random initial value. The softmax activation function is used at the output layer to perform motor fault classification.Figure 2
Architecture of the 1D CNN model.


## 3.2. Exemplar Set Selection

The exemplar setEi is adjusted in each incremental phase i using the Herding method [17], as shown in Algorithm 1. The exemplar selection is required when training data are available. Feature representation from dataset Di is obtained using the feature extractor Gf (line 2). Each sample is normalized employing the L2 norm (line 3). Notice that m exemplars are selected and stored iteratively for each class (lines 5–7). One sample is added to the exemplar set in each iteration, prioritizing that sample that makes the average feature vector better approximate the mean vector.Algorithm 1: Herding method.
Inputs:Xc=x1,…,xnc: dataset of class c; m: number of exemplars to select; Gf: feature extractorOutput:E: exemplar set(1)
InitializeE to the empty set {}(2)
Zc←GfXc \(⊳\) Get feature representations(3)
Z^c←Zc/Zc2 \(⊳\) L2 norm(4)
z¯←1/nc∑z^∈Z^cz^ \(⊳\) Get mean feature vector(5)
fork=1,…,mdo(6)
pk←argminz^∈Z^cz¯−1/kGfz^+∑j=1k−1Gfpj2(7)
end for(8)
E←p1,…,pmAlgorithm 2: Nearest centroid classifier.
Inputs:E0:i=p1,…,pt: exemplar set from phase 0 to i; Gf: feature extractor; xt: sample to be classifiedOutput:y∗: one hot vector of the class label; C: number of classes(1)
Z^←GfE0:i \(⊳\) Get feature representations(2)
forc=1,…,Cdo(3)
p¯c←argminp1∈Z^c∑p2∈Z^cdp1,p2(4)
end for(5)
y∗←argminc∈1,…,Cp¯c−Gfxt2 \(⊳\) nearest prototype


## 3.3. Nearest Centroid Classifier

Nearest centroid classifier (NCC) [24] is a nearest-neighbor classifier, which is used to address the bias produced on new classes by training CNN over imbalanced data. The procedure followed by NCC is described in Algorithm 2. First, feature representations from exemplars E0:i are obtained using the feature extractor Gf (line 1). The centroid is computed as the point from which the sum of the distances of all exemplars that belong to that particular class are minimized (lines 2–4). NCC assigns the label of the most similar class centroid to the test sample xt (line 5) as follows:(8)y∗=argminc∈1,…,Cdp¯c,Gfxt,where p¯c is the centroid vector for the class c, obtained from exemplars E0:i; meanwhile, d is the Euclidean distance.


## 4. Experimental Setup

This section first describes data from the different cases of study used in multiclass incremental learning for motor fault diagnosis. Next, the experimental protocol is described. Finally, we present the implementation details of the MCIL model.


### 4.1. Cases of Study

Our experiments were conducted on two cases of study based on vibration analysis: (1) motor common fault diagnosis and (2) bearing fault diagnosis. For this, we used two public benchmark datasets: asynchronous motor common fault (AMCF) [1] and Case Western Reserve University (CWRU) [25]. Tables 1 and 2 present the description of the data acquisition and studied faults for the AMCF and CWRU datasets, respectively. The AMCF dataset is composed of 8,000 samples from 8 motor conditions (1,000 per class), where each sample contains 1,024 points. For the CWRU dataset, experiments were performed under 1 hp workload. This dataset contains three types of fault locations in bearing (balls, inner race, and outrace), showing fault diameters of 0.007, 0.014, and 0.021 inches. CWRU contains 10,000 samples from 10 different motor conditions (1,000 per class), including health bearings.Table 1
Description of the AMCF dataset.
Data acquisitionsMotor4 hp YE2-100L2-4Sensor typeCT1020 L accelerometerSignal descriptionVibration signals were collected using an acquisition card PCI-1716 with a sampling frequency of 250 kS/s, high-resolution of 16 bits, and 16 SE/8 DI channelsFault descriptionType of faultThe damages of the motors are as follows: short circuit of 2 turns (SC2T), short circuit of 4 turns (SC4T), short circuit of 4 turns (SC8T), air-gap eccentricity (AE), rotor bar broken (RBB), bearing cage broken (BCB), and bearing abrasion fault (BAF)Table 2
Description of the CWRU dataset.
Data acquisitionsMotor2 hp reliance electricSensor typeAccelerometersSignal descriptionVibration signals were collected using a 16-channel DAT recorder. Digital data was collected at 12k samples/secondFault descriptionBearing6205-2RS JEM SKF, deep groove ball bearingFault locationBalls, inner race, and out raceFault diameters0.007, 0.014, and 0.021 inch


### 4.2. Experimental Protocol

For each dataset, we evaluated the proposed MCIL model starting from a pretrained CNN over initial data of motor faults; meanwhile, the rest of the data coming in different phases are used to train CNN in a class-incremental way. First, we fix the number of stored exemplars to the smallest memory size allowed, and after, the number of incremental phases is varied. Next, we fix the number of incremental phases to 6 and 8 for AMCF and CWRU, while the number of exemplars per fault is varied consideringm=5 and m=10. In each incremental phase, faults are given in a fixed random order; 80% of the data samples in each class are used for training, and the remaining 20% for testing, performing a stratified sampling. The final model in each incremental phase is used to classify classes observed so far. Experiments were repeated five times using different random initial weights, different partitions of data, and a different fault order. We calculate the average accuracy and standard deviation only for incremental states, which are of interest for MCIL. Our comparison includes the results of CNN employing all previous data available (Full) and those using a fine-tuning procedure with a random selection of exemplars (FT + R).


### 4.3. Implementation Details and Model Parameter Selection

Table3 presents the details of the 1D CNN model. We used filters with a large (101), medium (51), and small (11) size to learn features from raw signals. In addition, max-pooling layers were used with a size and stride of 3 to reduce spatial feature dimensions. The 1D CNN model employs a total of 56,281 trainable parameters. The 1D CNN model was implemented in Pytorch 1.7.0, whereas NCC was obtained from scikit-learn library (https://scikit-learn.org/stable/). Experiments were performed using a PC Intel(R) Core (TM) i7 with a graphic card GTX 1080 Nvidia on Ubuntu 20.04 LTS.Table 3
Implementation details of the 1D CNN model.
BlockLayer nameHyperparametersNumber of trainable parametersInputSample input—SincNetFilters=30, size=101, stride=160SincNetActivation functionReLU—Max-poolingSize=3, stride=3—Convolution 1DFilters=30, size=51, stride=145,930Conv1Activation functionReLU—Max-poolingSize=3, stride=3—Conv2Convolution 1DFilters=30, size=11, stride=19,930Activation functionReLU—GAPGlobal average pooling——OutputFully connectedC units361Activation functionSoftmax—In our experiments, the 1D CNN model was trained by Adam algorithm [26] during 40 and 30 epochs for the AMCF and CWRU datasets, respectively. For both datasets, the initial learning rate was set to 0.0001 at the initial phase, whereas it was set to 0.001 for incremental phases. In addition, a learning decay of 0.1 was applied at 30 and 20 epochs. Likewise, a batch size of 30 was selected from {10, 30, 50} for both datasets. This hyperparameter setting was selected after comparing different configurations across 6 and 8 incremental phases on AMCF and CWRU; 5 exemplars from each past class (known faults) were stored in memory. For model parameter selection, we used coordinate descent [27], which changes only one hyperparameter at a time, aiming the best configuration. Fine-tuning and Herding selection (FT + H) were used for CNN retraining and exemplar selection in each incremental phase. Experimental results, as shown in Table 4, indicate that the batch size has a lower negative impact compared with learning rate. For both datasets, the 1D CNN model achieves its highest average accuracy when the learning rate is 0.001 and the batch size is 10 and 30. This last value of batch size was selected because it requires a lower number of iterations for data processing during training. Finally, as shown in Figure 3, the 1D CNN model stabilizes its training above 20 and 15 epochs on AMCF and CWRU for the different incremental phases. Using 40 and 30 epochs during training, we ensure a stabilization of the 1D CNN model.Table 4
Accuracy results of 1D CNN on AMCF and CWRU datasets, using different batch sizes and learning rates.
Batch sizeLearning rateAMCF1030500.010.0010.00011D CNN (FT + H)94.97 ± 3.4094.24± 3.9691.20± 07.0680.05± 08.3394.24 ± 03.9658.67± 14.14CWRU1D CNN (FT + H)98.77± 0.8398.78 ± 0.8398.68± 01.0966.42± 09.6698.78 ± 00.8387.58± 06.10Best results are boldfaced for each setting.Figure 3
Accuracy performance of 1D CNN (FT + H) across different epochs. We show the accuracy performance for the different incremental phases.
(a)(b)


## 4.1. Cases of Study

Our experiments were conducted on two cases of study based on vibration analysis: (1) motor common fault diagnosis and (2) bearing fault diagnosis. For this, we used two public benchmark datasets: asynchronous motor common fault (AMCF) [1] and Case Western Reserve University (CWRU) [25]. Tables 1 and 2 present the description of the data acquisition and studied faults for the AMCF and CWRU datasets, respectively. The AMCF dataset is composed of 8,000 samples from 8 motor conditions (1,000 per class), where each sample contains 1,024 points. For the CWRU dataset, experiments were performed under 1 hp workload. This dataset contains three types of fault locations in bearing (balls, inner race, and outrace), showing fault diameters of 0.007, 0.014, and 0.021 inches. CWRU contains 10,000 samples from 10 different motor conditions (1,000 per class), including health bearings.Table 1
Description of the AMCF dataset.
Data acquisitionsMotor4 hp YE2-100L2-4Sensor typeCT1020 L accelerometerSignal descriptionVibration signals were collected using an acquisition card PCI-1716 with a sampling frequency of 250 kS/s, high-resolution of 16 bits, and 16 SE/8 DI channelsFault descriptionType of faultThe damages of the motors are as follows: short circuit of 2 turns (SC2T), short circuit of 4 turns (SC4T), short circuit of 4 turns (SC8T), air-gap eccentricity (AE), rotor bar broken (RBB), bearing cage broken (BCB), and bearing abrasion fault (BAF)Table 2
Description of the CWRU dataset.
Data acquisitionsMotor2 hp reliance electricSensor typeAccelerometersSignal descriptionVibration signals were collected using a 16-channel DAT recorder. Digital data was collected at 12k samples/secondFault descriptionBearing6205-2RS JEM SKF, deep groove ball bearingFault locationBalls, inner race, and out raceFault diameters0.007, 0.014, and 0.021 inch


## 4.2. Experimental Protocol

For each dataset, we evaluated the proposed MCIL model starting from a pretrained CNN over initial data of motor faults; meanwhile, the rest of the data coming in different phases are used to train CNN in a class-incremental way. First, we fix the number of stored exemplars to the smallest memory size allowed, and after, the number of incremental phases is varied. Next, we fix the number of incremental phases to 6 and 8 for AMCF and CWRU, while the number of exemplars per fault is varied consideringm=5 and m=10. In each incremental phase, faults are given in a fixed random order; 80% of the data samples in each class are used for training, and the remaining 20% for testing, performing a stratified sampling. The final model in each incremental phase is used to classify classes observed so far. Experiments were repeated five times using different random initial weights, different partitions of data, and a different fault order. We calculate the average accuracy and standard deviation only for incremental states, which are of interest for MCIL. Our comparison includes the results of CNN employing all previous data available (Full) and those using a fine-tuning procedure with a random selection of exemplars (FT + R).


## 4.3. Implementation Details and Model Parameter Selection

Table3 presents the details of the 1D CNN model. We used filters with a large (101), medium (51), and small (11) size to learn features from raw signals. In addition, max-pooling layers were used with a size and stride of 3 to reduce spatial feature dimensions. The 1D CNN model employs a total of 56,281 trainable parameters. The 1D CNN model was implemented in Pytorch 1.7.0, whereas NCC was obtained from scikit-learn library (https://scikit-learn.org/stable/). Experiments were performed using a PC Intel(R) Core (TM) i7 with a graphic card GTX 1080 Nvidia on Ubuntu 20.04 LTS.Table 3
Implementation details of the 1D CNN model.
BlockLayer nameHyperparametersNumber of trainable parametersInputSample input—SincNetFilters=30, size=101, stride=160SincNetActivation functionReLU—Max-poolingSize=3, stride=3—Convolution 1DFilters=30, size=51, stride=145,930Conv1Activation functionReLU—Max-poolingSize=3, stride=3—Conv2Convolution 1DFilters=30, size=11, stride=19,930Activation functionReLU—GAPGlobal average pooling——OutputFully connectedC units361Activation functionSoftmax—In our experiments, the 1D CNN model was trained by Adam algorithm [26] during 40 and 30 epochs for the AMCF and CWRU datasets, respectively. For both datasets, the initial learning rate was set to 0.0001 at the initial phase, whereas it was set to 0.001 for incremental phases. In addition, a learning decay of 0.1 was applied at 30 and 20 epochs. Likewise, a batch size of 30 was selected from {10, 30, 50} for both datasets. This hyperparameter setting was selected after comparing different configurations across 6 and 8 incremental phases on AMCF and CWRU; 5 exemplars from each past class (known faults) were stored in memory. For model parameter selection, we used coordinate descent [27], which changes only one hyperparameter at a time, aiming the best configuration. Fine-tuning and Herding selection (FT + H) were used for CNN retraining and exemplar selection in each incremental phase. Experimental results, as shown in Table 4, indicate that the batch size has a lower negative impact compared with learning rate. For both datasets, the 1D CNN model achieves its highest average accuracy when the learning rate is 0.001 and the batch size is 10 and 30. This last value of batch size was selected because it requires a lower number of iterations for data processing during training. Finally, as shown in Figure 3, the 1D CNN model stabilizes its training above 20 and 15 epochs on AMCF and CWRU for the different incremental phases. Using 40 and 30 epochs during training, we ensure a stabilization of the 1D CNN model.Table 4
Accuracy results of 1D CNN on AMCF and CWRU datasets, using different batch sizes and learning rates.
Batch sizeLearning rateAMCF1030500.010.0010.00011D CNN (FT + H)94.97 ± 3.4094.24± 3.9691.20± 07.0680.05± 08.3394.24 ± 03.9658.67± 14.14CWRU1D CNN (FT + H)98.77± 0.8398.78 ± 0.8398.68± 01.0966.42± 09.6698.78 ± 00.8387.58± 06.10Best results are boldfaced for each setting.Figure 3
Accuracy performance of 1D CNN (FT + H) across different epochs. We show the accuracy performance for the different incremental phases.
(a)(b)


## 5. Results

### 5.1. Case 1: Motor Common Fault Diagnostics

Table5 shows the average accuracy and standard deviation (SD) on AMCF using a different number of incremental phases and exemplars. We observed that the most challenging scenario is presented when one exemplar per fault is retained across different incremental phases. Inversely, we can see that the most straightforward scenario is presented when a greater number of exemplars per fault is stored (m=5 and m=10). Notice that the performance of FT + R (fine-tuning with a random selection) dropped when m=1 and the number of incremental phases decreased. In this scenario, the proposed MCIL framework (FT + NCC + H) obtained average accuracies beyond 94%, outperforming to FT + R at least 20 percentage points (pp). Moreover, we can see that FT + NCC + H achieved average accuracies of 98.32% and 98.85% over 6 incremental phases and a number of exemplars m equal to 5 and 10, outperforming to FT + R by 5.07 and 3.79 pp.Table 5
Accuracies and standard deviations (SD) over AMCF using a different number of incremental phases and exemplars.
m=1Phases=61 phase3 phases6 phasesm=5m=10FT + R55.40± 03.8568.96± 14.6375.66± 08.3793.25± 03.6795.06± 03.53FT + NCC + H96.70 ± 02.3394.73 ± 02.0396.22 ± 02.2698.32 ± 00.9198.85 ± 00.63Full99.38± 00.31Best results are boldfaced for each setting.


### 5.2. Case 2: Bearing Fault Diagnostics

Table6 shows the average accuracies and standard deviations (SD) on CWRU using a different number of incremental phases and exemplars. The most challenging scenario is presented when m=1, where the performance of FT + R dropped when the number of phases increased. In this scenario, FT + NCC + H achieved average accuracies beyond 93%, outperforming FT + R at least 6.27 pp. On the other hand, we observed that FT + NCC + H outperformed FT + R by only 0.48 and 0.39 pp across 8 incremental phases, while the number of exemplars is 5 and 10.Table 6
Average accuracy and standard deviation (SD) for MCIL methods over CWRU, using a different number of incremental phases of exemplars.
m=1Phases=81 phase4 phases8 phasesm=5m=10FT + R91.65± 03.4083.90± 03.4481.22± 04.2298.65± 01.0098.86± 00.96FT + NCC + H97.92 ± 01.1894.77 ± 00.8893.36 ± 01.9699.13 ± 00.5499.25 ± 00.39Full100.0± 0.00Best results are boldfaced for each setting.


### 5.3. Ablation Studies

#### 5.3.1. Effect of Each Component

We analyzed the impact of each component to determine its contribution over the final accuracy on AMCF and CWRU. Figure4 shows the accuracy performance on AMCF and CWRU during 6 and 8 incremental phases, although one exemplar is retained in memory. Notice that accuracy results of FT without memory also were included. For both datasets, we observed that FT reduces its accuracy performance over incremental phases if memory is not available, suggesting the presence of the catastrophic forgetting problem. We can see that fine-tuning results significantly improved when memory is incorporated (FT + H), storing representative samples from past faults. Finally, notice that NCC also had a positive impact on the final accuracy (FT + NCC + H) by reducing the bias generated by incorporating new faults.Figure 4
Impact of each component of FT + NCC + H on (a) AMCF and (b) CWRU across 6 and 8 incremental phases, retaining one exemplar per fault. Accuracy results of FT without (w/o) memory also were included.
(a)(b)


#### 5.3.2. Effect of the Number of Exemplars

Figure5 shows the impact on accuracy performance by varying the number of exemplars per fault. We observed that FT + R improved its results when the number of stored exemplars increased, while FT + NCC + H obtained results above 96% starting from 1 exemplar per class. We can see that FT + NCC + H achieved a competitive performance (98.32% vs. 99.38%) than training on full data, storing at least 5 exemplars per fault, while FT + R became competitive by using more than 20 exemplars.Figure 5
Impact of the number of exemplars stored in memory: (a) AMCF and (b) CWRU.
(a)(b)Regarding the CWRU results, we can see that the worst performance is obtained when the number of stored exemplars per class is 1. Moreover, FT + R and FT + NCC + H increased their accuracy performance starting from 2 samples per fault. FT + NCC + H obtained an average accuracy above 99%, storing at least 3 exemplars per fault, while FT + R achieved the same performance above 5 exemplars.


#### 5.3.3. Effect of the Herding Method for Exemplar Selection

We studied the impact of the exemplar selection via Herding and a random selection over the accuracy performance on AMCF and CWRU. Figure6 shows the accuracy performances on AMCF and CWRU across 6 and 8 incremental phases, while a different number of exemplars from past faults are retained. For AMCF, we observed that the Herding method (marked as + H) slightly improves the accuracy performance over random selection (marked as + R) when 1 to 10 exemplars are retained. For CWRU, only improvements can be seen when 2 to 5 exemplars are retained. We observed that random selection obtained a similar or even better performance than the herding method for the rest of the cases.Figure 6
Impact of the herding method for exemplar selection on (a) AMCF and (b) CWRU. Herding method is marked as + H, whereas a random selection is marked as + R.
(a)(b)


#### 5.3.4. Effect of Noise over the Proposed Framework

In order to test the performance of the proposed framework under different noise conditions, we applied additive white Gaussian noise (AWGN) to the raw signals from the test set; 6 and 8 incremental phases were used on AMCF and CWRU, retaining 5 exemplars from past classes. Table7 presents the classification results of FT + NCC + H under three different noise levels; accuracy results of FT + H (CNN trained incrementally) and the full model (CNN using all data) were included as reference. As expected, evaluated solutions reduced their average accuracy when a lower noise level is applied. However, we can see that FT + NCC + H obtained average accuracies beyond 92% and 94% when an SNR = 5 is applied on signals from AMCF and CWRU, respectively. For AMCF and CWRU, FT + NCC + H obtained the best average accuracies when SNR is 5 and 10, while it obtained a similar accuracy performance compared with the full model when SNR is 15.Table 7
Accuracy performances and standard deviations for evaluated solutions under different noise levels on AMCF and CWRU.
SNR51015AMCFFull74.21± 00.9194.41± 01.7099.45± 00.21FT + H85.68± 03.3793.55± 04.1494.96± 03.32FT + NCC + H92.51± 03.2298.15± 01.0398.39± 00.89CWRUFull70.16± 06.1896.20± 01.1399.81± 00.07FT + H77.74± 07.0893.25± 02.8497.33± 01.62FT + NCC + H94.35± 04.4998.77± 01.0398.92± 00.89


#### 5.3.5. Comparison of Classification Time

We analyzed the classification times of our proposed framework (FT + NCC + H) across different incremental phases; we included times of FT + H (CNN trained incrementally) as reference. For this experiment, 6 and 8 incremental phases were used for AMCF and CWRU, although 5 exemplars from each learned class were stored in memory. Table8 shows the classification times for evaluated solutions. We can see that times increased when new classes are added to the 1D CNN classifier. Also, we observed that the times of FT + NCC + H did not significantly increase with respect to FT + H (CNN as classifier). From this, notice that NCC uses a reduced number of exemplars from past and current faults as training set.Table 8
Classification time (seconds) across different incremental phases.
AMCFIncremental phasesFT + HFT + NCC + HInitial0.10920.108410.11730.138620.13400.144330.14030.158840.16520.170450.16770.186260.19050.2034CWRUIncremental phasesFT + HFT + NCC + HInitial0.10870.106710.11290.124020.13080.133630.14620.149840.15550.166950.15900.182160.18360.207770.20110.216480.20930.2355


## 5.1. Case 1: Motor Common Fault Diagnostics

Table5 shows the average accuracy and standard deviation (SD) on AMCF using a different number of incremental phases and exemplars. We observed that the most challenging scenario is presented when one exemplar per fault is retained across different incremental phases. Inversely, we can see that the most straightforward scenario is presented when a greater number of exemplars per fault is stored (m=5 and m=10). Notice that the performance of FT + R (fine-tuning with a random selection) dropped when m=1 and the number of incremental phases decreased. In this scenario, the proposed MCIL framework (FT + NCC + H) obtained average accuracies beyond 94%, outperforming to FT + R at least 20 percentage points (pp). Moreover, we can see that FT + NCC + H achieved average accuracies of 98.32% and 98.85% over 6 incremental phases and a number of exemplars m equal to 5 and 10, outperforming to FT + R by 5.07 and 3.79 pp.Table 5
Accuracies and standard deviations (SD) over AMCF using a different number of incremental phases and exemplars.
m=1Phases=61 phase3 phases6 phasesm=5m=10FT + R55.40± 03.8568.96± 14.6375.66± 08.3793.25± 03.6795.06± 03.53FT + NCC + H96.70 ± 02.3394.73 ± 02.0396.22 ± 02.2698.32 ± 00.9198.85 ± 00.63Full99.38± 00.31Best results are boldfaced for each setting.


## 5.2. Case 2: Bearing Fault Diagnostics

Table6 shows the average accuracies and standard deviations (SD) on CWRU using a different number of incremental phases and exemplars. The most challenging scenario is presented when m=1, where the performance of FT + R dropped when the number of phases increased. In this scenario, FT + NCC + H achieved average accuracies beyond 93%, outperforming FT + R at least 6.27 pp. On the other hand, we observed that FT + NCC + H outperformed FT + R by only 0.48 and 0.39 pp across 8 incremental phases, while the number of exemplars is 5 and 10.Table 6
Average accuracy and standard deviation (SD) for MCIL methods over CWRU, using a different number of incremental phases of exemplars.
m=1Phases=81 phase4 phases8 phasesm=5m=10FT + R91.65± 03.4083.90± 03.4481.22± 04.2298.65± 01.0098.86± 00.96FT + NCC + H97.92 ± 01.1894.77 ± 00.8893.36 ± 01.9699.13 ± 00.5499.25 ± 00.39Full100.0± 0.00Best results are boldfaced for each setting.


## 5.3. Ablation Studies

### 5.3.1. Effect of Each Component

We analyzed the impact of each component to determine its contribution over the final accuracy on AMCF and CWRU. Figure4 shows the accuracy performance on AMCF and CWRU during 6 and 8 incremental phases, although one exemplar is retained in memory. Notice that accuracy results of FT without memory also were included. For both datasets, we observed that FT reduces its accuracy performance over incremental phases if memory is not available, suggesting the presence of the catastrophic forgetting problem. We can see that fine-tuning results significantly improved when memory is incorporated (FT + H), storing representative samples from past faults. Finally, notice that NCC also had a positive impact on the final accuracy (FT + NCC + H) by reducing the bias generated by incorporating new faults.Figure 4
Impact of each component of FT + NCC + H on (a) AMCF and (b) CWRU across 6 and 8 incremental phases, retaining one exemplar per fault. Accuracy results of FT without (w/o) memory also were included.
(a)(b)


### 5.3.2. Effect of the Number of Exemplars

Figure5 shows the impact on accuracy performance by varying the number of exemplars per fault. We observed that FT + R improved its results when the number of stored exemplars increased, while FT + NCC + H obtained results above 96% starting from 1 exemplar per class. We can see that FT + NCC + H achieved a competitive performance (98.32% vs. 99.38%) than training on full data, storing at least 5 exemplars per fault, while FT + R became competitive by using more than 20 exemplars.Figure 5
Impact of the number of exemplars stored in memory: (a) AMCF and (b) CWRU.
(a)(b)Regarding the CWRU results, we can see that the worst performance is obtained when the number of stored exemplars per class is 1. Moreover, FT + R and FT + NCC + H increased their accuracy performance starting from 2 samples per fault. FT + NCC + H obtained an average accuracy above 99%, storing at least 3 exemplars per fault, while FT + R achieved the same performance above 5 exemplars.


### 5.3.3. Effect of the Herding Method for Exemplar Selection

We studied the impact of the exemplar selection via Herding and a random selection over the accuracy performance on AMCF and CWRU. Figure6 shows the accuracy performances on AMCF and CWRU across 6 and 8 incremental phases, while a different number of exemplars from past faults are retained. For AMCF, we observed that the Herding method (marked as + H) slightly improves the accuracy performance over random selection (marked as + R) when 1 to 10 exemplars are retained. For CWRU, only improvements can be seen when 2 to 5 exemplars are retained. We observed that random selection obtained a similar or even better performance than the herding method for the rest of the cases.Figure 6
Impact of the herding method for exemplar selection on (a) AMCF and (b) CWRU. Herding method is marked as + H, whereas a random selection is marked as + R.
(a)(b)


### 5.3.4. Effect of Noise over the Proposed Framework

In order to test the performance of the proposed framework under different noise conditions, we applied additive white Gaussian noise (AWGN) to the raw signals from the test set; 6 and 8 incremental phases were used on AMCF and CWRU, retaining 5 exemplars from past classes. Table7 presents the classification results of FT + NCC + H under three different noise levels; accuracy results of FT + H (CNN trained incrementally) and the full model (CNN using all data) were included as reference. As expected, evaluated solutions reduced their average accuracy when a lower noise level is applied. However, we can see that FT + NCC + H obtained average accuracies beyond 92% and 94% when an SNR = 5 is applied on signals from AMCF and CWRU, respectively. For AMCF and CWRU, FT + NCC + H obtained the best average accuracies when SNR is 5 and 10, while it obtained a similar accuracy performance compared with the full model when SNR is 15.Table 7
Accuracy performances and standard deviations for evaluated solutions under different noise levels on AMCF and CWRU.
SNR51015AMCFFull74.21± 00.9194.41± 01.7099.45± 00.21FT + H85.68± 03.3793.55± 04.1494.96± 03.32FT + NCC + H92.51± 03.2298.15± 01.0398.39± 00.89CWRUFull70.16± 06.1896.20± 01.1399.81± 00.07FT + H77.74± 07.0893.25± 02.8497.33± 01.62FT + NCC + H94.35± 04.4998.77± 01.0398.92± 00.89


### 5.3.5. Comparison of Classification Time

We analyzed the classification times of our proposed framework (FT + NCC + H) across different incremental phases; we included times of FT + H (CNN trained incrementally) as reference. For this experiment, 6 and 8 incremental phases were used for AMCF and CWRU, although 5 exemplars from each learned class were stored in memory. Table8 shows the classification times for evaluated solutions. We can see that times increased when new classes are added to the 1D CNN classifier. Also, we observed that the times of FT + NCC + H did not significantly increase with respect to FT + H (CNN as classifier). From this, notice that NCC uses a reduced number of exemplars from past and current faults as training set.Table 8
Classification time (seconds) across different incremental phases.
AMCFIncremental phasesFT + HFT + NCC + HInitial0.10920.108410.11730.138620.13400.144330.14030.158840.16520.170450.16770.186260.19050.2034CWRUIncremental phasesFT + HFT + NCC + HInitial0.10870.106710.11290.124020.13080.133630.14620.149840.15550.166950.15900.182160.18360.207770.20110.216480.20930.2355


## 5.3.1. Effect of Each Component

We analyzed the impact of each component to determine its contribution over the final accuracy on AMCF and CWRU. Figure4 shows the accuracy performance on AMCF and CWRU during 6 and 8 incremental phases, although one exemplar is retained in memory. Notice that accuracy results of FT without memory also were included. For both datasets, we observed that FT reduces its accuracy performance over incremental phases if memory is not available, suggesting the presence of the catastrophic forgetting problem. We can see that fine-tuning results significantly improved when memory is incorporated (FT + H), storing representative samples from past faults. Finally, notice that NCC also had a positive impact on the final accuracy (FT + NCC + H) by reducing the bias generated by incorporating new faults.Figure 4
Impact of each component of FT + NCC + H on (a) AMCF and (b) CWRU across 6 and 8 incremental phases, retaining one exemplar per fault. Accuracy results of FT without (w/o) memory also were included.
(a)(b)


## 5.3.2. Effect of the Number of Exemplars

Figure5 shows the impact on accuracy performance by varying the number of exemplars per fault. We observed that FT + R improved its results when the number of stored exemplars increased, while FT + NCC + H obtained results above 96% starting from 1 exemplar per class. We can see that FT + NCC + H achieved a competitive performance (98.32% vs. 99.38%) than training on full data, storing at least 5 exemplars per fault, while FT + R became competitive by using more than 20 exemplars.Figure 5
Impact of the number of exemplars stored in memory: (a) AMCF and (b) CWRU.
(a)(b)Regarding the CWRU results, we can see that the worst performance is obtained when the number of stored exemplars per class is 1. Moreover, FT + R and FT + NCC + H increased their accuracy performance starting from 2 samples per fault. FT + NCC + H obtained an average accuracy above 99%, storing at least 3 exemplars per fault, while FT + R achieved the same performance above 5 exemplars.


## 5.3.3. Effect of the Herding Method for Exemplar Selection

We studied the impact of the exemplar selection via Herding and a random selection over the accuracy performance on AMCF and CWRU. Figure6 shows the accuracy performances on AMCF and CWRU across 6 and 8 incremental phases, while a different number of exemplars from past faults are retained. For AMCF, we observed that the Herding method (marked as + H) slightly improves the accuracy performance over random selection (marked as + R) when 1 to 10 exemplars are retained. For CWRU, only improvements can be seen when 2 to 5 exemplars are retained. We observed that random selection obtained a similar or even better performance than the herding method for the rest of the cases.Figure 6
Impact of the herding method for exemplar selection on (a) AMCF and (b) CWRU. Herding method is marked as + H, whereas a random selection is marked as + R.
(a)(b)


## 5.3.4. Effect of Noise over the Proposed Framework

In order to test the performance of the proposed framework under different noise conditions, we applied additive white Gaussian noise (AWGN) to the raw signals from the test set; 6 and 8 incremental phases were used on AMCF and CWRU, retaining 5 exemplars from past classes. Table7 presents the classification results of FT + NCC + H under three different noise levels; accuracy results of FT + H (CNN trained incrementally) and the full model (CNN using all data) were included as reference. As expected, evaluated solutions reduced their average accuracy when a lower noise level is applied. However, we can see that FT + NCC + H obtained average accuracies beyond 92% and 94% when an SNR = 5 is applied on signals from AMCF and CWRU, respectively. For AMCF and CWRU, FT + NCC + H obtained the best average accuracies when SNR is 5 and 10, while it obtained a similar accuracy performance compared with the full model when SNR is 15.Table 7
Accuracy performances and standard deviations for evaluated solutions under different noise levels on AMCF and CWRU.
SNR51015AMCFFull74.21± 00.9194.41± 01.7099.45± 00.21FT + H85.68± 03.3793.55± 04.1494.96± 03.32FT + NCC + H92.51± 03.2298.15± 01.0398.39± 00.89CWRUFull70.16± 06.1896.20± 01.1399.81± 00.07FT + H77.74± 07.0893.25± 02.8497.33± 01.62FT + NCC + H94.35± 04.4998.77± 01.0398.92± 00.89


## 5.3.5. Comparison of Classification Time

We analyzed the classification times of our proposed framework (FT + NCC + H) across different incremental phases; we included times of FT + H (CNN trained incrementally) as reference. For this experiment, 6 and 8 incremental phases were used for AMCF and CWRU, although 5 exemplars from each learned class were stored in memory. Table8 shows the classification times for evaluated solutions. We can see that times increased when new classes are added to the 1D CNN classifier. Also, we observed that the times of FT + NCC + H did not significantly increase with respect to FT + H (CNN as classifier). From this, notice that NCC uses a reduced number of exemplars from past and current faults as training set.Table 8
Classification time (seconds) across different incremental phases.
AMCFIncremental phasesFT + HFT + NCC + HInitial0.10920.108410.11730.138620.13400.144330.14030.158840.16520.170450.16770.186260.19050.2034CWRUIncremental phasesFT + HFT + NCC + HInitial0.10870.106710.11290.124020.13080.133630.14620.149840.15550.166950.15900.182160.18360.207770.20110.216480.20930.2355


## 6. Discussion

In experiments, we evaluated and validated the proposed MCIL framework on two different cases of study for motor fault detection in IMs. The evaluation was performed under scenarios where data from new faults are streamed in different time phases. From the results, we found that the MCIL framework allows the incorporation and detection of past and new motor faults from vibration signals with high accuracy across different incremental phases. Unlike previous works [14, 15], one or more faults can be added to the 1D CNN model in each incremental phase. Notice that computational requirements and memory should be bounded. In this sense, the proposed MCIL framework maintains a constant complexity while a few samples from past faults are retained. To the best of our knowledge, this is the first work that studies MCIL, based on a deep learning approach, for fault diagnosis in IMs from vibration signals.From ablation studies, we observed that a neural network model tends to forget previously learned faults. This problem is known as catastrophic forgetting, which is produced by incorporating new faults into a pretrained model in a sequential way. In this direction, we found that the fine-tuning procedure with a memory of exemplars and the NCC classifier provides an effective solution to tackle the catastrophic forgetting problem [16] for fault diagnosis in IMs. As expected, the average accuracies of evaluated solutions significantly improved when the number of retained exemplars in memory increased. Notice that results on AMCF showed that at least 5 exemplars per fault are required across 6 incremental phases to achieve a competitive accuracy than training on full data. Also, we found that at least 3 exemplars were required across 8 incremental phases to obtain a similar performance using all data on CWRU. Notice that this amount of stored exemplars per fault represents approximately 1% of the size of the training set. Moreover, AMCF results showed that a greater number of incremental phases do not negatively impact the accuracy performance of the 1D CNN model; CWRU results showed that a greater number of incremental phases negatively impact the MCIL model’s accuracy performance. Concerning to the exemplar selection, we found that the herding method slightly improved over the accuracy results than using a random selection when a few exemplars are retained, but similar or even worst results were obtained in other cases. Regarding noise conditions, we found that FT + NCC + H provides a robustness to disturbances in signals, outperforming to the full model in accuracy performance for SNRs with low values. In particular, we found that NCC helps to face such disturbances in signals. Finally, we found that NCC does not increase the classification time because a reduced number of samples are used as training set.


## 7. Conclusions

This study presents a MCIL framework based on fine-tuning with a memory of exemplars and the nearest centroid classifier (NCC) over an 1D convolutional neural network (CNN), to incorporate new motor faults from vibration signals to already known. Specifically, 1D CNN is fine-tuned over samples from new faults and exemplars from known (past) faults, whereas NCC is used during testing phase to classify samples from past and new faults. The proposed framework was evaluated over two datasets for motor fault diagnosis: AMCF and CWRU. Different experimental scenarios were considered, including different numbers of incremental phases and stored exemplars. Experiments showed that the proposed framework achieved an accuracy performance beyond 93% and 94% on AMCF and CWRU, retaining one exemplar per fault and varying the number of incremental phases. We found that 5 and 3 exemplars per fault across 6 and 8 phases on AMCF and CWRU are required to achieve competitive accuracy than training with full data (98.32% vs. 99.38% and 99% vs. 100.00%). These results suggest that the catastrophic forgetting problem can be reduced by the proposed framework over AMCF and CWRU. Another interesting finding is that NCC may help to obtain a robust classifier when noise is presented in data. Using this proposed framework, we showed that a classifier, based on a deep learning model, may be trained incrementally, achieving satisfactory diagnosis results for fault detection in IMs and maintaining a constant complexity of the model. As future work, we are interested in developing an end-to-end MCIL framework, where the feature extractor and the classifier can be trained jointly. Likewise, we are planning to extend our study for the diagnostic of incipient and electrical faults.



---

*Source: 6627740-2021-10-27.xml*