Condition Monitor System for Rotation Machine by CNN with Recurrence Plot

Abstract

Induction motors face various stresses under operating conditions leading to some failure modes. Hence, health monitoring for motors becomes essential. In this paper, we introduce an effective framework for fault diagnosis of 3-phase induction motors. The proposed framework mainly consists of two parts. The first part explains the preprocessing method, in which the time-series data signals are converted into two-dimensional (2D) images. The preprocessing method generates recurrence plots (RP), which represent the transformation of time-series data such as 3-phase current signals into 2D texture images. The second part of the paper explains how the proposed convolutional neural network (CNN) extracts the robust features to diagnose the induction motor’s fault conditions by classifying the images. The generated RP images are considered as input for the proposed CNN in the texture image recognition task. The proposed framework is tested on the dataset collected from different 3-phase induction motors working with different failure modes. The experimental results of the proposed framework show its competitive performance over traditional methodologies and other machine learning methods.

1. Introduction

Induction motors are electromechanical devices used in most industrial applications. Due to their simple design and well-developed manufacturing technologies, induction motors are considered relatively reliable and robust [1]. However, the motors fall into failure mode and seriously affect industrial operations. Eventually, this leads to failure of the entire operating system if the failure condition is not identified or if it is neglected. Several types of faults related to winding, stator, rotor, and bearing can be observed in an induction motor [2,3]. There are mainly four types of fault diagnosis methods such as signal-based, model-based, knowledge-based, and active/hybrid methods. Signal-based methods use the measured signal to extract the features and make a diagnostic decision based on the prior knowledge of the diagnostic process. Signal-based methods can be classified into a time-domain signal-based method, frequency-domain signal-based method, and time-frequency signal-based method. Model-based methods can be categorized into deterministic fault diagnosis methods, fault diagnosis methods for discrete-events and hybrid systems; stochastic fault diagnosis; and fault diagnosis methods for distributed and network systems, which are categorized by the model type used [4]. Hybrid methods are studied as a combination of two or more fault diagnosis methods. For example, He et al. [5] diagnosed plastic bearing faults by combining the signal-based and data-driven methods. By combining signal-based and knowledge-based techniques, a fault diagnosis method was studied to detect the inter-turn faults in induction motors, in which wavelet transform is applied to extract the features from the collected vibration signals, and the principal component analysis (PCA) and neural network (NN) were used as classifiers to classify healthy from faulty motors [6]. Active methods are studied as a system in which a suitably designed input signal is injected into a dynamic process during a test period to distinguish accurately and quickly the faulty modes from the normal modes. Stochastic active fault diagnosis and deterministic active fault diagnosis are the two active methods studied [7,8,9]. For example, Campbell et al. [10], used two candidate models one as a normal system and another as a fault system in a multimodel system, and an auxiliary signal was designed to detect the correct model under a given interval of test time. As an extended study, an active fault detection method for multiple faults generated simultaneously or sequentially [11].

Knowledge-based methods, also considered as data-driven methods, are the most commonly used methods for analyzing signals such as vibration, temperature, electrical tension, and current. These methods require a huge amount of historical data to find the patterns in the given signal. However, data signals can be captured using sensors [12,13]. Signal-based features are extracted, and feature selection methods are applied to reduce feature dimensions and also to avoid the repeated information, which in turn improves the performance by holding the significant features [14]. The extracted features are used for fault diagnosis by various traditional machine learning methods [15,16,17]. Traditional machine learning methods have achieved prominent results. However, feature extraction depends significantly on diagnostic knowledge and signal processing expertise. Furthermore, traditional methods are incapable of extracting discriminative features from raw data and always require a process to extract the feature from the signal [16,18,19,20,21].

In spite of the advanced development in machine learning, deep learning (DP) has become the most effective study that can significantly overcome the drawbacks of traditional machine learning methods for fault diagnosis. DP can automatically extract and learn abstract features from raw data, and avoid manual feature extraction [18]. Many deep learning models, such as deep belief network (DBN) [22], stacked sparse auto-encoder [19], sparse auto-encoder [21], denoising auto-encoder [23] and sparse filtering [24] have been studied to diagnose the faults, and very significant results have been achieved. One of the most effective used deep learning model, called convolutional neural network (CNN), has been used to learn hierarchical feature representation from raw data and has delivered promising results [20,21,22,23,24,25].

Most pattern recognition tasks deal with time-series data signals. Financial data (stock and currency exchange rates), video processing, music mining, weather and forecasting, biometric data, and biomedical signal processing are few examples, in which time-series data have been studied [26,27,28]. Likewise, electrical industrial devices also often work with time-series data such as measurements of voltage, current, temperature, and vibration signals. One-dimensional CNN has been studied and applied to time-domain machinery data signals to diagnose the faults in induction motors [29]. In a few cases, machinery data can also be represented in two-dimensional (2D) model, such as the time-frequency domain using the wavelet transform technique [30]. In addition, time-series data can be represented in 2D texture images using the concept called recurrence plot (RP) [31]. Image representation of time-series data provides a different set of features that are not available for 1D signals. Therefore, 2D texture images can be used for classification [32].

In this study we use a time-series data signals converted as recurrence plots (RP) to feed the proposed deep CNN for fault diagnosis. Current signals with a phase difference were collected from 3-phase induction motors, and each phase current was used as an input data sample. Our results show that RP provides an effective method for viewing trajectory periodicity over a phase space, allowing us to discover specific elements of the m-dimensional phase space trajectory using a 2D figure. The main contributions of this paper are illustrated as follows. First, the raw current signals are represented as RP images. Second, an efficient deep CNN model is studied and applied on RP images to extract the multi-level features for fault classification. Lastly, the proposed deep CNN based framework achieves significant results compared to other deep learning methods.

The rest of the paper is arranged in the following way: Section 2 discusses the related works. Section 3 explains the proposed framework—time-series data to 2D texture image conversion—and proposed deep CNN models are discussed. Section 4 presents the experimental results followed by the conclusions and future work presented in Section 5.

2. Related Works

This section briefly reviews recent deep learning contributions on induction motors’ fault diagnosis. Several types of signal processing methodologies have been studied in the time-domain, frequency-domain, and time-frequency domain to extract and learn the features in order to classify the working condition of the motor. Lee et al. [33] studied the convolutional deep belief network (CDBN) to classify audio signals. They converted time-domain into frequency-domain data to learn the features form audio signals. A multi-channel CNN has been studied to handle multi-variate time-series data [34]. A separate CNN is used to learn the features from individual time-series data, and result from all the CNNs are combined and classified using a fully connected multilayer perceptron (MLP) classifier. Audio signals are transformed into a time-frequency domain to feed into CNN for classification [35]. The Gramian Angular Field (GAF) and Markov Transition Field (MTF) are used to convert time-series signals as images. A tiled CNN is used to classify time-series images [36,37].

Ngaopitakkul et al. [15] explain a decision algorithm based on ANN for fault diagnosis. Pandya et al. [17] propose an efficient KNN (k-Nearest Neighbours) classifier using the asymmetric proximity function for fault diagnosis. Yang et al. [16] constructed an SVM (Support Vector Machine)-based method to diagnose the fault patterns of the roller bearings. Jia et al. [38] propose a fault diagnosis method based on deep neural networks using an auto-encoder. Deep learning models such as deep autoencoder (DAE), deep belief network (DBN), and CNN have been discussed for fault diagnosis [19,20,22]. Ince et al. [26] propose a one-dimensional (1D) CNN to diagnose faults using real-time motor data. Abdeljaber et al. [39] studied 1D CNN to detect real-time structural damages. A deep CNN was used to analyze multichannel time-series data signals for human activities [40]. However, these models only used a small amount of low-level features in hidden layers. However, in this paper, we study a deep CNN method to automatically learn the useful texture features in order to classify faults. 1D raw current signals were converted to 2D images, and the proposed CNN model was able to successfully capture the temporal and spatial dependencies in the images by applying relevant filters. Furthermore, the proposed model was able to extract and learn high-level features from these images along with the low-level features. The performance of fault classification improved by the combined implementation of feature extraction and the CNN classifier.

3. Proposed Study and Framework

This section explains the proposed framework based on RP images and deep CNN for fault diagnosis. It consists of two subsections: (1) the time-series data signals are converted into 2D texture images, and (2) a deep convolutional neural network model is discussed to learn features from texture images for fault classification.

3.1. Time-Series Data to 2D Texture Images

The time-series data can be categorized using a unique recurring behavior such as periodic and irregular cyclic aspects. Moreover, time-series data are generated as the repetition of states, which is a normal phenomenon for ever-changing irregular systems or random processes. RP [31,32] is a tool for visualizing and investigating the m-dimensional phase space trajectory using a 2D representation of its repetitive occurrences. The primary idea of RP is to disclose trajectory movements from the current state to the previous state and it can be formulated as:

$$R_{i,j}=\theta \left(ϵ-\Vert \overrightarrow{{\mathit{s}}_l}-\overrightarrow{{\mathit{s}}_m}\Vert \right),\overrightarrow{\mathit{s}}\left(.\right)\in {\Re }^n,l,m=1,2,\dots \dots ,K$$

where K is the number of states $\overrightarrow{\mathit{s}}$ , ϵ is a threshold value of distance, ‖. ‖ is the norm and θ(.) is the Heaviside function. The recurrence matrix (R) comprises two sets of values called texture and typology. The texture information belongs to individual dots, sloping lines, perpendicular lines, and horizontal lines, whereas the typology information categorized by uniform, regular, shift, and interrupted. Obviously, in RP, there are patterns and information that are not easily visually seen and interpreted. The detailed explanation can be found in [32].

Raw current signals are collected from 3-phase induction motors for the fault analysis every 5 s with a sampling rate of 10,000 samples per second. Data samples taken for different periods of time from 1 s to 5 s were investigated with recurrence plots. Five seconds of data samples gave the most distinguishable patterns in the recurrence plots. The collected raw current signals from the operating induction motor are represented as recurrence plot shown in Figure 1.

As shown in the Figure 2, nondistinguishable recurrence plots were generated for two different motors operating with different modes of failure, when the raw current signal values were used to generate recurrence plots. Even though, the motors working with different modes such as faulty or healthy, it can be clearly seen that it is almost impossible to find a distinguishable pattern in these recurrence plots—they look exactly the same with no difference in any color or pattern. However, to find distinguishable patterns in RP images, an effective preprocessing technique called Max–Min difference was used in this study, and it is implemented as follows:

Step 1: maximum and minimum peaks of the current signal are collected for each one full cycle.

Step 2: difference between the maximum and minimum peak value is then used to generate the recurrence plot for the whole signal.

Step 3: the above two steps are repeated for all types of faults, and healthy motor signals generate distinguishable recurrence plot.

As shown in the Figure 3, after applying the preprocessing technique to raw current signal values, the generated recurrence plots are well distinguishable and can be considered for classification of different faults and healthy conditions of the motors by CNN. Initially, the 2D recurrence texture images were generated by raw one dimensional (1D) current signals and then classifier automatically learned the features from texture images to classify the motors’ fault condition.

3.2. The Methodology’s Architecture

The methodology’s architecture consists of two parts. Part one explains the architecture used to train the CNN model and part two belongs to motor testing using the trained model.

The relevant data were collected for a total of five conditions of the induction motor. A setup of four induction motors for the following four faults and one motor for the healthy condition were used. The four faults were: (1) bearing axis deviation, (2) stator and rotor friction, (3) rotor end ring break, and (4) poor insulation.

As shown in Figure 4, the training setup had two stages. The first stage setup was done in one of the lab servers (lab server). Data for all conditions of the motor were collected in this server in CSV format. The dataset comprised of 3-phase current signals. Data preprocessing was applied to the raw current signals to generate the recurrence plots. Recurrence plots’ 2D texture images were stored into the S3 database hosted on the cloud platform (EI-PaaS).

The second stage setup is in the cloud. The Edge Intelligent Platform as a Service (EI-PaaS) has the analytical framework service, where the CNN model was implemented along with the S3 database. While training the CNN model, the images were maintained in the temporary directory structure. Figure 5 illustrates the setup used for the deployment/testing phase of the application. The architecture has a 3-phase induction motor connected to a data acquisition system (DAQ), which sends motor-related data such as current signal values in binary format to an Edge device. The Edge device reads the binary data and converts the data into decimal format and stores them as a CSV file. The data stored in the CSV file are used to generate the relevant RP image. The generated RP texture image is fed to the well-trained CNN model to diagnose and classify the motor condition as one of the four faults or healthy condition.

3.3. Architecture of the Proposed CNN Model

The proposed deep CNN model has a three-stage structure. Each stage representing a feature learning stage with different feature-levels and it includes convolution, activation, and pooling layers.

As shown in Figure 6, the proposed deep CNN model has three convolutional layers with 32–3 × 3 filter, 64–3 × 3 filter, and 128–3 × 3 filter, respectively. In addition, three max-pooling layers of pooling size 2 × 2 were used. Type of layers, output shape of each layer, along with the number of trainable parameters are listed in

Table 1. Proposed CNN model summary.

Layer (Type)	Output Shape	Param #
conv2d_4 (Conv2D)	(None, 1, 64, 32)	18,464
leaky_re_lu_5 (LeakyReLU)	(None, 1, 64, 32)	0
max_pooling2d_4 (MaxPooling2)	(None, 1, 32, 32)	0
conv2d_5 (Conv2D)	(None, 1, 32, 64)	18,496
leaky_re_lu_6 (LeakyReLU)	(None, 1, 32, 64)	0
max_pooling2d_5 (MaxPooling2)	(None, 1, 16, 64)	0
conv2d_6 (Conv2D)	(None, 1, 16, 128)	73,856
leaky_re_lu_7 (LeakyReLU)	(None, 1, 16, 128)	0
max_pooling2d_6 (MaxPooling2)	(None, 1, 8, 128)	0
flatten_2 (Flatten)	(None, 1024)	0
dense_2 (Dense)	(None, 128)	131,200
leaky_re_lu_8 (LeakyReLU)	(None, 128)	0
dense_3 (Dense)	(None, 5)	645

Total params: 242,661, Trainable params: 242,661, Non-trainable params: 0.

.

The activation function Leaky ReLU (Rectified Linear Units) was applied to introduce nonlinearity into each stage, allowing CNN to learn complex models. A specific reason for adding Leaky ReLU was to avoid and attempt to fix the problem of dying ReLUs. It has proven to be more effective than the logistic sigmoid function. However, during the training, ReLU units can die and this could occur when large gradient flows through a ReLU neuron. It causes the weights to update such that the neuron will never activate again on any data point. Leaky ReLU makes an attempt to solve this problem [41,42]. Pooling layers were introduced to reduce the resolution of the input image by the process of subsampling and the max-pooling was applied in the proposed model.

At the end of the three stages, the feature maps were flattened into a column vector. The flatted output vector supplied to a feed-forward neural network and backpropagation was employed to every iteration of training. During training, the proposed model was able to distinguish among the dominating and also low-level features in texture images and classify by a fully connected layer for five types of faults. To estimate the parameters of the proposed model, one of the gradient-based optimization (backpropagation algorithm) methods was used. Adam optimizer was used to update the parameters to achieve faster convergence [43].

4. Experimental Results and Discussion

To assess the performance of the proposed methodology, raw current signals from an experimental setup of a total of five induction motors with the same configuration were used. One healthy and four fault types of raw current data signals were collected from the experimental setup. The different five current signals were studied and analyzed for the healthy condition of the motor, as well as for the following four faulty conditions of the motors [44]. The raw signal to image conversion method and the CNN model implementation were written in python 3.6 with TensorFlow and run on the Windows 64 bit operating system.

4.1. Healthy and Fault Conditioned Motors

• Bearing axis deviation: this condition is considered as class ‘Fault 1’. This happens due to the offset of centers on both sides of coupling when the motor is connected to load.
• Stator and rotor friction: this condition of the motor is considered as ‘Fault 2’. Due to the friction and overheating, the stator or rotor coil is short-circuited and hence it will breakdown if it is not diagnosed and fixed.
• Rotor end ring break: this condition is considered as ‘Fault 3’. Due to the high frequency and overloaded operation of the motor, the excessive current may cause the breaking of the rotor bar.
• Poor insulation: this condition is considered as ‘Fault 4’. This occurs due to the rapid change of the current or voltage.
• Healthy: this condition is considered as ‘Fault 0’ for the classification. Current signal values are collected from the motor working in normal condition.

The proposed framework uses induction motor raw current signal values to generate recurrence plots for respective conditions. Generated recurrence plots are used as input images to the CNN model for further classification on the fault conditions of motors.

4.2. Dataset

The dataset was collected from a lab setup for four fault scenarios and one healthy scenario. The setup included five motors each for four faults and one healthy condition operating at full load. The dataset consisted of 750 samples and 150 samples for each type of scenario as described in

Table 2. Dataset considered for evaluation.

Fault 0	Fault 1	Fault 2	Fault 3	Fault 4	Total
150	150	150	150	150	750

. At 5 s of sampling rate, 50,000 raw current signal data points were collected per sample.

The dataset was divided mainly into three parts as described in the

Table 3. Dataset samples used for evaluation.

Data Split Ratio
Training	60%	450
Validation	15%	112
Testing	25%	188

. Sixty percent of the dataset (450 data samples for training) and 15% of the dataset (112 data samples for validation) were used simultaneously to train the CNN model. The remaining 20% (188 data samples) were used to test the trained CNN model.

4.3. Performance Results of the Proposed CNN

The proposed deep CNN model was trained over 100 epochs to learn the multi-level features for one healthy and for each type of the motors’ faulty condition. The deep CNN model was trained to automatically train and learn the robust features from 450 samples of training data and simultaneously validated against 112 data samples during each iteration. Then, the trained deep CNN model was tested against the 188 samples of the testing dataset. The proposed deep CNN model was trained and verified with a batch of 16, 32, and 64. The deep CNN model achieved the best results with a batch of size 32.

The accuracies and losses were collected for each iteration while training the proposed deep CNN model, and plotted as shown in the Figure 7. The CNN model was able to learn the complex features efficiently with reaching almost 100% accuracy, and ~97–98% validation accuracy. Over the 100 epochs, the proposed deep CNN model was able to learn the generalized features from the recurrence plot texture images to diagnose the induction motor faults and classify the motors as faulty or healthy.

The performance of the proposed deep CNN was evaluated using a testing dataset consisting of 188 data samples. The performance results of the trained deep CNN model were very prominent with an average accuracy of 98% as described in

Table 4. Classification report on the test dataset.

Classification Report
CLASS	Precision	Recall	F1-Score	Support
Fault 0	1.00	1.00	1.00	38
Fault 1	1.00	0.89	0.94	37
Fault 2	0.95	1.00	0.97	38
Fault 3	1.00	1.00	1.00	37
Fault 4	0.95	1.00	0.97	38
Accuracy			0.98	188
Macro avg	0.98	0.98	0.98	188
Weighted avg	0.98	0.98	0.98	188

. The classification report clearly explains how well the proposed deep CNN model was able to extract and learn the features from the testing data samples and classify the features into respective classes. In the classification report, the average values of the evaluation metrics such as precision, recall, and f1 score on test dataset were impressive, with 98% of accuracy. The proposed model was able to classify Fault 3 and Fault 0 (healthy) conditions accurately. However, the proposed model misclassified other faults, but with an acceptable margin. The confusion matrix for the test data was calculated using the trained deep CNN model (Figure 8). Almost all test samples were accurately classified with very few misclassifications.

In order to evaluate the performance of the proposed framework relative to traditional and other deep learning methods, the proposed framework was compared and the performance metrics were collected in terms of accuracy. The proposed framework was compared to support vector machine SVM [45], artificial neural network (ANN) [22], adaptive deep convolutional neural network (ADCNN) [46], sparse filter [24], and deep belief network (DBN) [22].

The prediction accuracy of these methods was calculated (

Table 5. Comparison results.

Methods	Accuracy (%)
SVM	88.2
ANN	87.8
ADCNN	98.4
Sparse filter	98.2
DBN	81.8
Proposed deep CNN	99.81

SVM: Support Vector Machine, DBN: Deep Belief Network, ANN: Artificial Neural Network, ADCNN: Adaptive Deep Convolutional Neural Network.

). Comparing the performance results explains the significant results achieved by the proposed deep CNN framework compared to the other methods listed above. A prediction accuracy of 99.81%, shows the significant performance from the proposed deep CNN model.

5. Conclusions and Future Work

In this study, we investigate and discuss a novel framework to diagnose the faults in 3-phase induction motors based on recurrence plots and the deep CNN model. The important contributions of this paper are: proposing a method to transform a time-series data signal to 2D texture images (recurrence plots) and applying the proposed deep CNN model to learn the features from the recurrence plots to classify the 2D texture images for the fault diagnosis. The proposed framework is implemented for four types of faults including bearing axis deviation, stator and rotor friction, rotor end ring break, and poor insulation, and achieved a very prominent accuracy of 99.81%. The proposed framework outperforms other traditional and deep learning models due to its ability to learn both high-level and low-level features. The proposed framework demonstrates promising results by considering a single variable as an input feature compared to the rule-based diagnosis methods that require multiple features for fault diagnosis.

The limitations of the proposed methodology are discussed as follows. First, the dataset collected for the experiment is comparatively small and a huge amount of data samples is needed for different load conditions such as no load, half load, or full load. Second, data from the motors with different specifications are needed to extract and learn more generalized features. Therefore, important future work should focus on motors working with different load conditions to collect more data samples, and investigating data to generate more generalized features for CNN model training. Furthermore, future work includes the review of transfer learning to avoid any unnecessary time required to train the model and utilize the model to learn other feature types.