# Guided Sampling-based Evolutionary Deep Neural Network for Intelligent Fault
Diagnosis

Arun K. Sharma  Student Member, IEEE and Nishchal K. Verma  Senior Member,
IEEE Arun K. Sharma and Nishchal K. Verma are with the Dept. of Electrical
Engineering, Indian Institute of Technology, Kanpur, India. e-mail:
<EMAIL_ADDRESS>and<EMAIL_ADDRESS>
###### Abstract

The diagnostic performance of most of the deep learning models is greatly
affected by the selection of model architecture and their hyperparameters. The
main challenges in model selection methodologies are the design of
architecture optimizer and model evaluation strategy. In this paper, we have
proposed a novel framework of evolutionary deep neural network which uses
policy gradient to guide the evolution of DNN architecture towards maximum
diagnostic accuracy. We have formulated a policy gradient-based controller
which generates an action to sample the new model architecture at every
generation. The best fitness obtained is used as a reward to update the policy
parameters. Also, the best model obtained is transferred to the next
generation for quick model evaluation in the NSGA-II evolutionary framework.
Thus, the algorithm gets the benefits of fast non-dominated sorting as well as
quick model evaluation. The effectiveness of the proposed framework has been
validated on three datasets: the Air Compressor dataset, Case Western Reserve
University dataset, and Paderborn university dataset.

Nowadays even if there are a lot of advancements in computational
intelligence, intelligent fault diagnosis requires good expertise to design
the diagnostic model. This is because the performance of most of the
diagnostic models depends on model selection and hyperparameters. The proposed
method of guided sampling-based evolutionary deep neural network non-dominated
sorting-based evolutionary algorithm to optimize the model architecture. The
model architecture is sampled by using a reward-based policy to force the
evolutionary algorithm to get a model architecture that can give maximum
accuracy. Therefore, the proposed method is the best solution for the model
architecture selection without any human expertise while ensuring the best
possible diagnostic performance.

Neural architecture search, Intelligent fault diagnosis, Deep neural network,
Non-dominated sorting algorithm, Policy gradient.

##  1 Introduction

With the advancement in modern computational technology, machine learning
based intelligent fault diagnosis has become an integral part of almost all
industrial sectors. Intelligent fault diagnosis refers to the preventive
maintenance of industrial machines using machine learning-based data analysis
and class detection [1, 2, 3, 4, 5, 6]. Data-driven fault diagnosis of
industrial machines faces many challenges: (i) labeled data availability as
running the machine in a faulty state with real-time load is not possible,
(ii) training the deep learning algorithms with limited availability of
labeled dataset, (iii) model selection best suited for the dataset under
consideration. A deep neural network (DNN) has been commonly used for
intelligent fault diagnosis due to its high capability of non-linear feature
transformation [7, 8]. However, training the DNN from scratch for every change
in the operating condition of the machine becomes an uneconomical process. To
solve such problems, many researchers have suggested a variety of domain
adaptation methods[9, 10, 11, 12, 13, 14, 15, 16]. [11], [14] and [15] uses
labeled source dataset from the laboratory machine and the unlabeled target
dataset from the test machine to train a model capable to diagnose the fault
on the test dataset from the target machine. A quick learning mechanism to
train the model in the target domain by transforming an already trained model
on source data. All these methods work well only if a suitable architecture is
selected based on trial and error and some prior experience with the dataset.
In practice, it becomes a big challenge for selecting and training the best
suitable architecture with every change in the dataset due to variations in
machine operating conditions and fault types.

Therefore, our main objective is to investigate and develop an algorithm that
can find a best suitable architecture for the given dataset with limited
computational resources and computational time. As the performance of most of
the deep learning algorithms is very much affected by the hyper-parameters,
research on hyper-parameter optimization or neural architecture search (NAS)
has gained very much attention nowadays [17, 18]. Based on architecture
optimization strategy, NAS methods are mainly categorized as: (i) random
search and grid search [19], (ii) surrogate model-based optimization [20],
(iii) reinforcement learning [21], (iv) genetic algorithm [22, 23, 24, 25,
26], (v) gradient descent [27], and (vi) hybrid algorithms [28]. In most of
the aforementioned methods, the biggest challenge for architecture search is
the model evaluation because of the complex training mechanism for most of the
deep learning models [18]. In genetic algorithm-based NAS methods, the
evolution of architecture takes many days of GPU. For example, regularized
evolution of image classifier [29] with 450 K40 GPU takes 3150 GPU days.
Architecture optimization using non-dominated sorting genetic algorithm II
(NSGA-II [30]) has also gained much attention due to the fast sorting
framework [31, 26]. EvoN2N [26] uses the concept of knowledge transfer for
fitness evaluation in the NSGA-II based framework. The quick fitness
evaluation with fast NSGA-II makes the algorithm faster compared to the state-
of-the-art evolutionary methods. In this paper, we extend the work of EvoN2N
[26] to introduce a guided sampling-based evolution that makes the convergence
faster while exploiting the search space with the help of a reward-based
controller. The key contributions of this work are highlighted below

  1. i)

We have formulated the guided sampling-based evolution of DNN architecture
(GS-EvoDNN) using policy gradient.

  2. ii)

We have introduced a mean and variance term to exploit the search space for
the model optimization.

  3. iii)

We have formulated an update law for mean and variance term using policy
gradient.

  4. iv)

We have adopted the knowledge transfer mechanism to initialize the weight
matrices of the model at a generation by using the best model from the
previous generation.

The rest of the article is organized as follows. Table 1 summarizes the
symbols commonly used throughout the literature except index variables on
summation and loop variables in algorithmic steps. Section 2 defines the
objective problem. Section 3 briefly discusses the related works and the
theoretical backgrounds. Section 4 explains the implementation details of the
proposed framework of GS-EvoDNN. Section 5 discussed the effectiveness of the
proposed framework for fault diagnosis under various load and operating
conditions of the machine. And finally, Section 6 concludes the whole paper.

Table 1: List of Symbols

Symbol | Description
---|---
$\mathcal{D}^{tr}$, $\mathcal{D}^{val}$, & $\mathcal{D}^{te}$ | Dataset, training, validation & test dataset
$\textbf{X}\in\Re^{(n_{s}\times n_{f})}$, $\textbf{y}\in\Re^{n_{s}}$ | Input data, Output labels
$n_{s}$ & $n_{f}$ | Number of samples & features
$C$ | number class of the dataset
$\Psi_{t}$ | DNN model at generation $t$
$\Psi_{t}^{\dagger}$ | Best DNN model at generation $t$
$\Lambda_{t},\,\mathcal{R}_{t}$ | Fitness matrix, Rank at generation $t$
$P_{t},\,Q_{t}$ | Population, Offspring at generation $t$
$n_{p}$ | number hidden layers in $p^{th}$ model
$h_{k}$ | Number nodes in $k^{th}$ hidden layer

##  2 Problem Statement

Let the training dataset, validation dataset, and test dataset are
$\mathcal{D}^{tr}=\left(\textbf{X}^{tr},\textbf{y}^{tr}\right)$,
$\mathcal{D}^{val}=\left(\textbf{X}^{val},\textbf{y}^{val}\right)$, and
$\mathcal{D}^{te}=\left(\textbf{X}^{te},\textbf{y}^{te}\right)$, respectively
where $\textbf{X}\in\Re^{(n_{s}\times n_{f})}$ be the input data with $n_{s}$
samples & $n_{f}$ features and $\textbf{y}\in\Re^{n_{s}}$ be the corresponding
output label. The objective of optimal DNN architecture search for fault
classification is mathematically be formulated as

$\displaystyle\Psi^{\dagger}=\mathcal{H}\left(P,\;\mathcal{D}^{tr},\;\mathcal{D}^{val}\right)$
(1)
$\displaystyle\hat{y}^{te}\;=\;\mathcal{F}\left(\Psi^{\dagger},\;X^{te}\right)$
(2)

where $\mathcal{H}(.)$ denotes the optimization function to get the best model
$\Psi^{\dagger}$ with optimal parameters for the training dataset and
$\mathcal{F}(.)$ is the feed-forward DNN function which predicts the fault
class $\hat{\textbf{y}}^{te}$ for the test data $\textbf{X}^{te}$.

##  3 Related Works and Theoretical Background

###  3.1 Deep Neural Network (DNN)

The deep neural network (DNN): a multi-layered neural network is the most
popular technique for pattern recognition via non-linear feature
transformation in multiple stages [32]. From the training point of view, DNN
can be considered as two parts: Stack of a given number of auto-encoders (
also called stacked auto-encoder: SAE) [33] and a classifier usually softmax
classifier as output layer. First, a greedy layer unsupervised training is
used to train each of the auto-encoder (AE) in the SAE. Then, the SAE stacked
with the classifier at the end layer is fine-tuned using a labeled training
dataset. The SAE with softmax classifier (DNN model $\Psi$) is depicted in
Fig. 1.

Figure 1: SAE with softmax classifier (DNN model: $\Psi$)

###  3.2 Intelligent Fault Diagnosis

Recently, with the advent of advanced machine learning techniques and the
availability of fast computational resources, the data-driven intelligent
fault diagnosis method has gained much popularity, [1, 2, 4, 3]. In these
methods, various machine learning techniques are utilized to learn the
specific signature of the recorded signals like current, vibration,
temperature, etc., and thereafter identify the existence of machinery fault
using the test samples. Neural network (NN) [34], Support vector machine (SVM)
[35, 36], and random forest (RF) classifier [5] have been very effectively
used for intelligent fault diagnosis and have been proved to be the baseline
method for pattern recognition. But the diagnostic performances by these
methods are reduced due to high sparsity and low-quality features in the
dataset [37]. The intelligent fault diagnosis using deep learning methods has
gained much attention due to its capability of multi-scale hierarchical
feature transformation and large dimensional data handling, [7, 8, 14].
However, using a deep neural network for fault diagnosis faces a major
challenge of training from scratch for every new operating condition of the
machines. The recent trend of using deep transfer learning methods for domain
adaptation has been very effective for fault diagnosis under changeable
operating conditions [9, 10, 12, 13, 38, 15, 16]. However, the diagnosis
performance by these methods is very much affected by the selection of the
architecture of the deep neural network and the other hyper-parameters.

###  3.3 Neural Architecture Search (NAS)

The main objective of NAS methods is to obtain the optimal architecture in a
given search space with the best model performance [18]. There are three
important aspects of the NAS methods: (i) formulation of the search space,
(ii) the architecture optimizer, and (iii) the model evaluation. Formulation
of search space defines the design format for the model architecture. It can
be categorized into four groups: (i) cell-based (ii) entire-structured, (iii)
morphism-based, and (iv) hierarchical search space. The most important aspect
of NAS methods is the model evaluation as it is computationally very expensive
to train each model during the search process and evaluate on the unseen
dataset. To accelerate the evolution, various mechanism have been suggested
for the model evaluation [18, 29, 39, 40, 20, 41, 42, 43]. K. Kandasamy,
et.al, [41] suggested learning the curve extrapolation for the model
performance evaluation instead to train and evaluate the actual architecture.
H. Pham et. al, [43] proposed the method of parameter sharing for the faster
training and evaluation of the model architecture.

Another important aspect of NAS methods is the architecture optimizer (AO).
The objective automatic AO is to automatically guide the model architecture
search in a direction to get the best suitable model for a given dataset. The
AO methods adopted by various researchers can be categorized as (i) random
search (RS) (ii) grid search (GS), (iii) surrogate model-based optimization
(SMBO), (iv) gradient descent (GD), (v) reinforcement learning (RL), (vi)
genetic algorithms (GA), and (vii) hybrid methods. In the RS method, the
search optimizer tries different architecture randomly from the defined search
space, [19], whereas, in GS, the search method uses a grid to sample and
evaluate the model architecture [40]. SMBO methods use Basian optimization
[20, 41, 42] or neural networks [44] as a surrogate model of the objective
function to obtain the most promising solution (the model architecture).
Gradient descent-based method uses softmax function to find the optimal
architecture over a continuous and differentiable search space [27]. In RL-
based NAS [21, 45], a controller (usually, a recurrent neural network)
generate an action to sample a new architecture. The observation (state) & the
reward from the environment is used to update the controller policy to
generate new architecture samples. Here, the training & validation process of
the sampled neural network is treated as the environment that returns back the
validation accuracy. GA-based NAS [22, 23, 24, 25, 46, 31], use heuristic
search to find the best performing architecture over a given search space. In
these methods, heuristically sampled neural architectures are trained and
evaluated using the convention neural training methods and the performance
metrics are used as fitness for evolution to obtain the optimal architecture.
The main challenge of these methods is the fitness evaluation of the
individual model All of these methods of AO have their own merits and
demerits. The hybridization of two of the above methods may give a significant
improvement in the search efficiency, called the hybrid method of AO [47, 28,
48].

###  3.4 Policy Gradient

Policy gradient (PG) is a tool to optimize the controller policy for
reinforcement learning algorithm [49, 50]. The controller policy is the
parameterized function that defines the learning agent’s way to act on the
environment to get maximum reward Fig. 2. The reward defines the good or bad
effect of the action taken by the policy towards the fulfillment of the
optimal objective. Let the parameter vector be $\theta_{t}$, then the
parameterized function policy is represented as
$\pi_{\theta_{t}}(a_{t}|s_{t})$, where $a_{t}$ and $s_{t}$ represent action
and state at given time $t$. Let the action $a_{t}$ produces reward $r_{t+1}$
from the environment, then the trajectory of state, action and reward can be
represented as
$\left((s_{0},a_{0},r_{1}),(s_{1},a_{1},r_{2}),....(s_{t},a_{t},r_{t+1})\right)$.
The policy parameter $\theta_{t}$ can be updated using policy gradient as

$\theta_{t+1}=\theta_{t}+\eta_{t}\nabla_{\theta_{t}}\mathcal{J}(\theta_{t})$
(3)

where $\eta_{t}$ denotes the learning rate at time $t$, usually a constant
real number. $\nabla_{\theta_{t}}\mathcal{J}(\theta_{t})$ denotes the policy
gradient and can be calculated using expected of cumulative reward ${U}_{t}$
over the time $t$ as follows.

$\displaystyle\nabla_{\theta_{t}}\mathcal{J}(\theta_{t})=\nabla_{\theta_{t}}E\left[{U}_{t}\right]=\nabla_{\theta_{t}}\int_{t}\pi(\tau)r(\tau)d(\tau)$
(4)
$\displaystyle=E\left[r(\tau).\nabla_{\theta_{t}}\log\pi_{\theta_{t}}(\tau)\right]$
(5)

$\nabla_{\theta_{t}}\mathcal{J}(\theta_{t})=\frac{1}{N}\sum_{k=1}^{N}r(k)\left(\sum_{t=1}^{T}\nabla_{\theta_{t}}\log\pi_{\theta_{t}}\left(a_{t}|a_{t-1:1};\theta_{t}\right)\right)$

(6)

##  4 Proposed Framework

In this section, the proposed framework of guided sampling-based evolutionary
DNN (GS-EvoDNN) is described in detail. The Fig 2 shows the schematic of the
workflow of GS-EvoDNN. In the figure, DNN architecture optimization in the
NSGA-II framework constitute the environment. The fitness of the best model is
termed as the reward. The sorted fitness of all the individuals in the
population is treated as the state of the controller. The controller policy
$\pi_{\theta_{t}}$ generates an action $a_{t}=[m_{t},\sigma_{t}]$, where
$m_{t}$ and $\sigma_{t}$ be the mean and variance for the sampling of DNN
architecture at generation $t$. Given the training dataset $\mathcal{D}^{tr}$
and the validation dataset $\mathcal{D}^{val}$, the algorithmic steps for the
GS-EvoDNN is presented in Algorithm 1. Our contributions are highlighted in
Algorithm 1 and are further discussed in the following sections.

Figure 2: Flow Diagram of guided sampling based NSGA-II. Figure 3: Variable-
length gene encoding strategy. Algorithm 1 GS-EvoDNN: The Main Framework

Input: $\mathcal{D}^{tr}\,\&\,\mathcal{D}^{val}$ = training & validation
datasets, $n_{R}\,\&\,h_{R}=$ Maximum depth & width of the DNN respectively
Output: $\Psi^{\dagger}$ = best model after the termination or last generation
of the evolution.

1:$t\longleftarrow 0$ //Set generation count ($t$) = 0;

2:$[m,\;\sigma]\longleftarrow$ Compute mean and variance from allowable range
for depth ($n_{R}$) and width ($h_{R}$) of the DNN.

3:$\textbf{$P_{0}$}\longleftarrow\textbf{GuidedPop}(m,\sigma,N_{p})$
//Generate $N_{p}$ number of populations using Algorithm 2.

4:$\Psi_{0}\longleftarrow$ Initialize weight matrices of the first model
($P_{0}\\{1\\}$) by small random numbers.

5:$\Lambda,\,\Psi_{1}^{\dagger}\longleftarrow\textbf{FitnessEval}(P_{0},\mathcal{D}^{tr},\mathcal{D}^{val},\Psi_{0})$
//Evaluate fitness of all individuals in $P_{0}$ using the Algorithm 3.

6:$\mathcal{R}\longleftarrow NonDominatedSorting(\Lambda_{1})$ //Assign rank
using non-dominated sorting [30].

7:$P_{1}\longleftarrow SelectParents(P_{0},\;\mathcal{R})\,$ //Select parents
bybinary tournament selection, [30].

8:${\Lambda}_{s}\\{1\\}\longleftarrow\Lambda$ //Store the fitness History.

9:$[m,\;\sigma]\longleftarrow\,\textbf{UpdateMeanVar}(P_{1},\;{\Lambda}_{s})$
//Update mean and variance term using the Algorithm 4.

10:$Q_{1}\longleftarrow\textbf{CrossoverMutation}(P_{1},m,\sigma))$ //Apply
crossover and mutation on $P$ using Algorithm 5.

11:$t\longleftarrow\;t+1$ //Update the generation count

12:while termination condition is false do

13:$S_{t}\longleftarrow(P_{t}\cup Q_{t})$ //Combine the parent population
($P_{t}$) & the child population ($Q_{t}$).

14:$\Lambda,\,\Psi_{t+1}^{\dagger}\longleftarrow\textbf{FitnessEval}(S_{t},\mathcal{D}^{tr},\mathcal{D}^{val},\Psi_{t}^{\dagger})$
//Evaluate fitness of all individuals in $S_{t}$ using the Algorithm 3.

15:$\mathcal{R}\longleftarrow NonDominatedSorting(\Lambda)$ //Assign rank by
non-dominated sorting of fitness $\Lambda$, [30].

16:$\mathcal{K}\longleftarrow CrowdingDistances(S_{t},\mathcal{R},\Lambda)$
//Find crowding distances of individuals in population set $S_{t}$, [30].

17:$P_{t+1}\longleftarrow SelectParentsByRankDist(S_{t},\mathcal{K},\Lambda)$
//Select parents by crowding distance and rank, [30].

18:$\Lambda_{s}\\{t+1\\}\longleftarrow\Lambda$ //Store the fitness History.

19:$[m,\;\sigma]\longleftarrow\,\textbf{UpdateMeanVar}(S_{t},\;\Lambda_{s})$
//Update mean and variance term using the Algorithm 4.

20:$Q_{t+1}\longleftarrow\textbf{CrossoverMutation}(P_{t+1},m,\sigma)$ //Apply
crossover and mutation on $P$ using Algorithm 5.

21: if Termination condition is true then

22: Exit

23: else

24: $t\longleftarrow t+1$ //Update the generation counter

25: end if

26:end while

27:Return: $\textrm{{Best
Model}}:\;\Psi^{\dagger}\longleftarrow\Psi_{t+1}^{\dagger}$ //Best model of
the last generation.

###  4.1 Population Sampling using Mean and Variance

AO includes depth and width variation in a defined search space. The real-
coded gene encoding strategy is adopted to encode the depth as the number of
genes (length of a chromosome) and the number of nodes in a hidden layer as
the value of a gene as shown in Fig. 3. Let $n_{R}$ & $h_{R}$ be the maximum
depth and width of the DNN, then the search space is defined as $[1\;n_{R}]$ &
$[1\;h_{R}]$ for depth and the width variations. The mean and variance
$m=[m_{1},m_{2}]$ & $\sigma=[\sigma_{1},\sigma_{2}]$) are initialized as
$m_{1}=(1+n_{R})/2,\;m_{2}=(1+h_{R})/2$ and
$\sigma_{1}=(n_{R}-1)/2,\;\sigma_{2}=(h_{R}-1)/2$.

Algorithm 2 GuidedPop: Population Sampling

Input: $N$ = Population size, $m=[m_{1},m_{2}]=$ mean &
$\sigma=[\sigma_{1},\sigma_{2}]=$ variance.
Output: $P$ = Population with $N$ chromosomes.

1:$H\longleftarrow$ generate $N$ Gaussian numbers with $m_{1}$ and
$\sigma_{1}$.

2:for p = 1 : N do

3:$h\longleftarrow H(p)$ : depth of $p^{th}$ chromosome

4:$tmp\longleftarrow$ generate $h$ Gaussian numbers with $m_{2}$ and
$\sigma_{2}$.

5:$P\\{p\\}\longleftarrow$ convert all numbers in $tmp$ to nearest integers.

6:end for

7:Return $P$

###  4.2 Fitness Evaluation

Fast model evaluation is the most important requirement for NAS, especially
when the evolutionary algorithm is used as an AO strategy. If the best model
at a generation is transferred for initialization of the DNN weight matrices
in the next generation, it makes the training and evaluation of the models
faster. The quick learning mechanism suggested in [16] is adopted for the
fitness evaluation as shown in Fig. 4. For the first generation, DNN models
are initialized randomly and trained using Limited-Broyden-Fletcher-Goldfarb-
Shanno (LBFGS) [51] algorithm. For next-generation and onward, the best model
obtained is transformed (Fig. 4) to initialize the models followed by fine-
tuning with the LBFGS algorithm for a few iterations only. If a model
$\Psi^{t}$ at generation $t^{th}$ has weight matrix $W^{t}$, the
classification loss $\mathcal{J}$ for a $C$ problem can be defined in term of
$[w,\,b]\in W^{t}$ as

$\displaystyle\mathcal{J}(W^{t})=\frac{1}{n^{s}}\left[\sum_{k=1}^{n^{s}}\sum_{i=1}^{C}I[y_{k}=c_{i}]\log{\frac{e^{(w_{i}^{T}f(x_{p})+b_{i})}}{\sum_{i=1}^{C}e^{(w_{i}^{T}f(x_{p}^{)}+b_{i})}}}\right]$
(7)

where, $f(x)=\Phi(wx+b)$ is the h-level features representation of DNN,
$y_{k}$ be the output label of the $k^{th}$ data sample and $c_{i}$ denotes
the $i^{th}$ class. The classification accuracy ($CA$) of fine-tuned model for
the validation data is returned as the fitness of that model.

Figure 4: Fitness evaluation strategy. Algorithm 3 FitnessEval: Fitness
Evaluation

Input: $P$ = Population with population size $N_{p}$,
$(\mathcal{D}^{tr},\mathcal{D}^{val})$ = Training & validation data.
Output: $\Lambda$ = Fitness matrix and $\Psi^{\dagger}$ = Best model.

1:$t\longleftarrow$ current generation

2:for $p\,=\,1\,:\,N_{p}$ do

3: $\Psi_{t}\longleftarrow\textrm{N2N}(\Psi_{t}^{\dagger})$ // Transform
$\Psi_{t}^{\dagger}$ as $p^{th}$ model using N2N transformation as depicted in
step-1 of Fig. 4.

4: Fine-tune the model ($\Psi_{t}$) on $\mathcal{D}^{tr}$ to minimize Eq. (7).

5: $\Lambda(p)\longleftarrow$ Find $CA$ of $\Psi_{t}$ on dataset
$\mathcal{D}^{val}$.

6:end for

7:$\Psi_{t}^{\dagger}\longleftarrow\textrm{Best model}$ // Find the model with
maximum $CA$ and minimum number of model parameters.

8:Return $\Lambda,\;\Psi_{t}^{\dagger}$

###  4.3 Update Mean and Variance using PG

Mean ($m$) and variance ($\sigma$) terms are used for sampling of a new
population as illustrated in Section-4.1. Here, we design a PG-based update
laws for $m$ & $\sigma$ such that the best fitness ($\max(\Lambda)$) is
maximized. At any generation $t$, $\max(\Lambda)$ is termed as reward,
$a_{t}=[m,\sigma]$ is termed as action, and weighted average of fitness
($\Lambda$) is termed as state of the policy. Thus, the policy generates
$[m^{T},\sigma^{T}]$ to guide the evolution for faster and better convergence.
For the design simplification, let us assume that the action is generated by a
deterministic policy as

$a_{t}=f(\theta_{t})=\frac{1}{1+e^{-\theta_{t}}}$ (8)

where, policy parameter $\theta_{t}$ is selected such that it controls
$m\in\Re^{2}$ (mean of depth and width of DNN) and $\sigma\in\Re^{2}$
(variance for depth and width of DNN). The parameter $\theta$ is updated by
the policy gradient in (3) calculated using gradient of expected total reward
$U_{t}$ derived in (6). The total cumulative reward is calculated using
fitness matrix $\Lambda_{t}$ at generation $t$ as in (9).

$U_{t}\;=\;\sum_{i=1}^{t}\frac{\max(\Lambda_{i})-\max(\Lambda_{i-1}}{\max(\Lambda_{i-1})}$
(9)

The algorithmic steps for the implementation of policy gradient based update
of $a_{t}=[m,\sigma]$ at generation $t$ is summarised in Algorithm 4.

Algorithm 4 UpdateMeanVar: Update $m$ & $\sigma$ using PG

Input: $P_{t}$ = Current population, $\Lambda$ = Fitness matrix,
$a_{t-1}=[m,\sigma]$ = Initial mean & variance term.
Output: $a_{t}=[m,\sigma]$ = Updated mean & variance.

1:$N=$ Number of models in $P_{t}$, $\alpha=$ Learning rate

2:$\bar{n}\longleftarrow$ Compute average depth of models in $P_{t}$

3:$\Omega=[\omega_{p}]_{p=1}^{N}$ //Generate a set of weights $\omega_{p}$
such that $\sum_{p=1}^{N}\omega_{p}=0$ and
$\omega_{1}>\omega_{2}>\,....\,>\omega_{N}$

4:$\Lambda_{t}^{sorted},idx$ = sort($\Lambda_{t}$, ‘descending’)

5:$P_{t}\longleftarrow$ Sort $P_{t}$ according to $idx$.

6:$n_{p}=$ no. of hidden layers (depth) in $p^{th}$ model.

7:$\delta_{p}=\max(H_{p})-\min(H_{p})$ //$H_{p}=$ set of nodes in hidden
layers of $p^{th}$ model

8:if $t\leq 1$ then

9:
$m=\sum_{j=1}^{N}\left[n_{p}\omega_{p}\;\;\;\frac{1}{n_{p}}\sum_{k=1}^{n_{p}}h_{kp}\omega_{p}\right]$
//$h_{kp}\in H_{p}$.

10:
$\sigma=\sum_{j=1}^{N}\left[(\bar{n}-n_{p})\omega_{p}\;\;\;\delta_{p}\omega_{p}/2\right]$

11:else

12: $\theta_{t-1}=\ln{\left[a_{t-1}/(1-a_{t-1})\right]}$

13: $U_{t}\longleftarrow$ Compute cumulative reward using (9).

14:
$s_{m}=\sum_{j=1}^{N}\left[n_{p}\omega_{p}\;\;\;\frac{1}{n_{p}}\sum_{k=1}^{n_{p}}h_{kp}\omega_{p}\right]$

15:
$s_{\sigma}=\sum_{j=1}^{N}\left[(\bar{n}-n_{p})\omega_{p}\;\;\;\delta_{p}\omega_{p}/2\right]$

16: $s_{t}=[s_{m}^{T}\;s_{\sigma}^{T}]$

17:
$\theta_{t}\longleftarrow\theta_{t-1}+\alpha*\frac{1}{N}\sum_{k=1}^{N}U_{t}E[\nabla\log{\pi_{\theta}(s_{t}|a_{t-1};\theta)}]$

18: $a_{t}={1}/{\left(1+e^{-\theta_{t}}\right)}$

19:end if

20:Return $a_{t}$

###  4.4 Crossover and Mutation

For the optimal search of the network architecture, a combination of
exploration and exploitation strategies is adopted. The guided sampling-based
generation of new population exploits the search space to force the evolution
towards maximum accuracy. To avoid local convergence, $N$ number of
individuals are sampled using $m$ and $\sigma$ based on Gaussian distribution,
and also $N$ number of parent populations are selected using crowding distance
and rank from the current generation. After that, the two populations are
merged to create a double-sized mating pool. Now, the two-step crossover
operator introduced in [26] is applied. The two steps are (i) single point
depth crossover (SPDC) for depth variation and (ii) common depth simulated
binary crossover (CDSBC) for gene value (width) alteration. The two-step
crossover method is depicted in Fig. 5. The whole process of offspring
generation is provided in Algorithm 5:

Figure 5: Two-steps crossover for chromosomes with different length. Algorithm
5 Offspring Generation: Crossover and Mutation

Input: $P$ = Parent population, $p_{c}$ = Crossover probability,
$(m,\sigma)$ = mean & variance term for sampling.
Output: $Q$ = Offspring population.

1:$Q\longleftarrow$ GuidedPop($m,\sigma,N,n_{R},h_{R}$) //Generate $N$
offspring populations using Algorithm 2.

2:$I_{c}=$ generate random indices of $p_{c}*100$% members from $P$.

3:for $i\in I_{c}$ do

4: Select $P_{1}=P\\{i\\}\;\&\;P_{2}=Q\\{i\\}$.

5: Find lengths ($n_{1},\;n_{2}$) of $P_{1},\;P_{2}$

6: Set a point $h<\min(n_{1},n_{2})$ on $P_{1},\;P_{2}$.

7: $C_{1},\,C_{2}\longleftarrow$ SPDC of $P_{1},\;P_{2}$ at point $h$ (as
depicted in step-1 of Fig. 5)

8: $\bar{C}_{1},\bar{C}_{2}\longleftarrow$ CDSBC for genes of the common depth
portion of $C_{1},\,C_{2}$ as depicted in step-2 of Fig 5.

9: Replace $Q\\{i\\}$ by $\bar{C}_{1}$ or $\bar{C}_{2}$.

10:end for

11:Return $Q$

##  5 Experimental Results and Discussion

The efficacy of the proposed framework of GS-EvoDNN is demonstrated on fault
diagnosis dataset under different operating conditions taken from (i) Air
compressor fault data [52], (ii) Paderborn University (PBU) bearing fault data
[53], and (iii) CWRU bearing fault data [54].

###  5.1 Experimental Setup

####  5.1.1 Air Compressor Fault Data [52]

The air compressor data contains acoustic signal recorded on single stage
reciprocating type air compressor driven by an $5hp$ induction motor installed
at the workshop, EE Department, IIT Kanpur. Data were recorded in eight
different cases: healthy and seven different faulty states of the air
compressor valve. Therefore, the dataset has 8 classes: (i) Healthy (H), (ii)
Leakage Inlet Valve (LIV), (iii) Leakage Outlet Valve (LOV), (iv) Non-Return
Valve (NRV), (v) Piston Ring (PR), (vi) Flywheel (F), (vii) Rider Belt (RB),
and (viii) Bearing (B). For each class, 225 measurements were taken with 50k
samples in each measurement.

####  5.1.2 PBU Bearing Fault Data [53]

PBU bearing fault data is the collection of time-series signals recorded on
electrical machine operating under wide variation of shaft load and rotational
speed. The four Load and speed settings (LS) are LS1: N09_M07_F10 (speed = 900
rpm, torque = 0.7 Nm & radial force = 1000 N), LS2: N15_M01_F10 (speed = 1500
rpm, torque = 0.1 Nm & radial force = 1000 N), LS3: N15_M07_F04 (speed = 1500
rpm, torque = 0.7 Nm & radial force = 400 N), and LS4: N15_M07_F10 (speed =
1500 rpm, torque = 0.7 Nm & radial force = 1000 N). Total of 32
experimentation with 6 healthy, 12 artificially damaged, and 14 damaged by
long run accelerated tests were conducted to record current, vibration signal,
radial forces, torque, and bearing temperature. The recorded signals contains
two types of faults: inner race (IR) fault and outer race (OR) fault.

####  5.1.3 CWRU Bearing Fault Data [54]

The CWRU bearing fault data provided by Case Western Reserve University (CWRU)
has been a widely used benchmark dataset for bearing fault diagnosis. It
contains vibration signal recorded at drive-end (DE) and fan-end (FE) of
bearing artificially seeded with inner race fault (IR), outer race (OR), and
rolling element ball (B) faults of variable fault diameters (F.D.) (from 0.007
to 0.028 inches). The bearing test rig setup details can be found in [54].

###  5.2 Segmentation and Data Processing

The recorded time-series signals contain a huge number of samples which is not
suitable for training the DNN. To make the dimension of the time-series
signals compatible with the DNN, we adopt a segmentation rule with the segment
length of approximately $1/4^{th}$ of data points recorded per revolution.
Here, we have selected segmentation lengths of 100, 200, & 400 for the CWRU
dataset, Air compressor dataset, and PBU dataset respectively. Also, the time-
series signals are usually unstructured and not to the scale. Therefore, we
have applied the min-max normalization technique to scale down the dataset to
$[0,\,1]$. The min-max normalization also removes the effect of outlier
points. If for some cases, the outlier points carry some important
information, then the z-score minimization technique may be used to make the
dataset well-structured [16].

###  5.3 Dataset Preparation

For the study of fault diagnosis with the proposed GS-EvoDNN, we prepare the
training, the validation, & the testing dataset under various operating
conditions described below.

Case-1 (T1): From Air Compressor Dataset, $7$ different cases of binary
classes and one case of multi-class diagnosis are investigated as listed in
table 2. For each class, 4 measurement files (having 50k samples/file) are
merged to create a sample of size $1000\times 200$ per class taking $200$
points as segment length.

Case-2 (T2): From CWRU FE Dataset, multi-class diagnosis with class name
healthy (H), inner race (IR), outer race (OR), and ball element (B) are
considered under different load ($1$, $2$, & $3$ hp) conditions and different
fault diameters (FD) ($7$, $14$, & $21$ mil). For each FD (for example, $7$
mil), dataset from all three load conditions are prepared. Thus, the fault
diagnosis on total of $9$ cases are presented as listed in table 3.

Case-3 (T3 & T4): From PBU Dataset, two different cases are considered (i) T3:
artificially damaged bearing fault and (ii) T4: bearing fault due to long
accelerated test. In both cases, multi-class diagnosis with three classes
namely H-OR-IR is studied under four load settings (LS) as listed in table 4.

Now for the training, the validation, & the testing, each of the above dataset
is split into three portions: $64\%$ train ($\mathcal{D}^{tr}$), $20\%$ test
($\mathcal{D}^{te}$), and $16\%$ validate ($\mathcal{D}^{val}$) datasets.

Table 2:  Air Compressor Dataset (T1): Diagnostic Performance in term of
Classification Accuracy

Class |  SVM [35] |  DNN [7] | DTL [13] | DAFD [12] | N2N [16] | EvoDCNN [25] | EvoN2N[26] | GS-EvoDNN
---|---|---|---|---|---|---|---|---
W. D. A. |  D. A.
H-LIV | 99.75 | 96.25 | 99.00 | 99.75 | 99.50 | 99.75 | 100.00 | 100.00 | 100.00
H-LOV | 98.25 | 95.75 | 99.25 | 99.66 | 99.25 | 99.25 | 99.75 | 99.75 | 100.00
H-PR | 98.25 | 93.25 | 93.30 | 98.75 | 97.75 | 98.75 | 98.25 | 99.75 | 99.75
H-B | 98.25 | 98.50 | 98.75 | 98.75 | 96.75 | 98.75 | 98.75 | 99.75 | 100.00
H-F | 99.25 | 99.25 | 99.00 | 98.75 | 99.25 | 99.25 | 99.25 | 100.00 | 100.00
H-NRV | 98.75 | 99.00 | 99.00 | 99.75 | 99.00 | 99.25 | 99.25 | 100.00 | 100.00
H-RB | 98.25 | 98.25 | 98.25 | 99.00 | 99.75 | 99.75 | 99.25 | 100.00 | 100.00
H-ALL | 97.75 | 99.25 | 99.00 | 99.00 | 99.25 | 99.25 | 99.75 | 99.75 | 100.00
S. D. | 0.65 | 2.16 | 2.00 | 0.46 | 1.02 | 0.38 | 0.57 | 0.13 | 0.09

Table 3:  CWRU FE Dataset (T2): Diagnostic Performance in term of
Classification Accuracy

Class |  F.D. |  Load |  SVM [35] |  DNN [7] | DTL [13] | DAFD [12] | N2N [16] | EvoDCNN [25] | EvoN2N[26] | GS-EvoDNN
---|---|---|---|---|---|---|---|---|---|---
W. D. A. |  D. A.
H-IR-OR-B |  DE 7 mil | 1hp | 88.12 | 96.69 | 96.56 | 97.94 | 98.94 | 98.94 | 99.60 | 100.00 | 100.00
2hp | 98.12 | 95.94 | 93.44 | 96.12 | 97.12 | 98.12 | 99.60 | 100.00 | 100.00
3hp | 99.10 | 98.75 | 98.75 | 98.44 | 99.44 | 99.44 | 99.70 | 100.00 | 100.00
DE 14 mil | 1hp | 99.10 | 94.75 | 96.88 | 97.19 | 99.19 | 99.67 | 100.00 | 100.00 | 100.00
2hp | 98.10 | 95.31 | 92.19 | 95.69 | 97.69 | 98.69 | 98.12 | 99.12 | 99.60
3hp | 99.25 | 96.88 | 94.69 | 97.62 | 99.33 | 98.62 | 98.44 | 98.84 | 100.00
DE 21 mil | 1hp | 96.88 | 86.56 | 84.69 | 89.62 | 95.62 | 96.62 | 93.75 | 98.75 | 100.00
2hp | 88.44 | 85.31 | 82.19 | 86.69 | 90.69 | 90.69 | 90.10 | 95.37 | 98.85
3hp | 92.19 | 86.56 | 79.38 | 88.06 | 91.06 | 92.06 | 92.81 | 95.81 | 98.81
S. D. | 4.62 | 5.25 | 7.06 | 4.66 | 3.46 | 3.32 | 3.69 | 1.81 | 0.51

Table 4: CA for Target-2 & Target-3 Dataset and for very limited samples of
Target-2 & Target-3 Dataset

Class |  Data- L.S. |  SVM [35] |  DNN [7] | DTL [13] | DAFD [12] | N2N [16] | EvoDCNN [25] | EvoN2N[26] | GS-EvoDNN
---|---|---|---|---|---|---|---|---|---
W. D. A. |  D. A.
H-OR-IR | T3-L1 | 94.25 | 96.92 | 96.92 | 96.92 | 98.64 | 98.94 | 99.25 | 99.75 | 100.00
T3-L2 | 90.00 | 93.58 | 95.00 | 94.58 | 95.12 | 96.12 | 99.58 | 99.83 | 99.75
T3-L3 | 87.17 | 91.92 | 93.33 | 92.08 | 94.44 | 94.44 | 97.50 | 97.70 | 100.00
T3-L4 | 87.17 | 93.15 | 93.75 | 94.17 | 97.19 | 95.28 | 100.00 | 100.00 | 100.00
T4-L1 | 95.00 | 97.50 | 97.50 | 98.33 | 98.33 | 99.17 | 99.17 | 100.00 | 100.00
T4-L2 | 92.83 | 95.92 | 96.50 | 96.33 | 96.33 | 96.33 | 98.60 | 99.15 | 100.00
T4-L3 | 94.83 | 94.67 | 93.33 | 94.17 | 95.72 | 96.33 | 98.60 | 99.15 | 100.00
T4-L4 | 94.83 | 95.33 | 95.00 | 95.83 | 95.69 | 95.69 | 93.33 | 98.75 | 99.75
S. D. | 3.41 | 1.92 | 1.65 | 1.95 | 1.50 | 1.68 | 2.13 | 0.79 | 0.10

###  5.4 Implementation Details

For the implementation of the proposed framework of GS-EvoDNN, the initial
parameters are selected as: population size ($N$) = 100, crossover probability
($P_{c}$) = 0.5, and the maximum number of generations is set to very high
usually at 50. Also, the termination criteria are set as either the validation
accuracy reaches 100% or it does not change continuously for 3 generations.
The allowable ranges for the variation of depth and width are selected as
$n_{R}\in[1,\;10]$ and $h_{R}\in[10,\;400]$ respectively. The learning rate
$\alpha=0.1$. The GS-EvoDNN framework is applied to the training dataset and
the best model obtained is tested for the test dataset under all cases (T1,
T2, T3, & T4) described in section 5.3. The classification accuracies ($CA$)
are tabulated in tables 2, 3, & 4.

For comparison and analysis, the state-of-the-art methods for intelligent
fault diagnosis best reported in various literature are selected as support
vector machines (SVM) [35], deep neural network (DNN) [7], deep transfer
learning (DTL) based on sparse autoencoder [13], Deep neural network for
domain Adaptation in Fault Diagnosis (DAFD) [12], Net2Net without domain
adaptation (N2N_WDA) [16], Net2Net with domain adaptation (N2N_DA) [16],
evolutionary deep CNN (EvoDCNN) [25], and evolutionary Net2Net (EvoN2N)[26].
The DNN, DTL, and DAFD are trained with hidden sizes as $(70-50-20)$. The
initial and hyper parameters for EvoDCNN and EvoN2N are kept same as mentioned
above. The same dataset (T1, T2, T3, & T4) are used to train and test all
these methods using the procedure suggested in the corresponding cited
references. The diagnostic performance in term of $CA$ are tabulated in tables
2, 3, & 4. The standard deviation (S.D.) of $CA$ calculated over the variation
in the operating conditions is also tabulated to compare the result deviation
with the change in the operating conditions.

Figure 6: TI in term of $\overline{CA}$ for (i) T1: Air Compressor dataset,
(ii) T2: CWRU dataset, (iii) T3: PBU dataset with single point fault, and (iv)
T4: PBU dataset with distributed fault. Figure 7: Confusion matrix for dataset
T4-L1 (Table 4): class label {‘1’, ‘2’, ‘3’} represents the class name {‘H’,
‘OR’, ‘IR’}.

###  5.5 Discussion

The diagnostic performances by the proposed method and the selected state-of-
the-art methods conclude the following important points.

  1. 1.

The $CA$ comparison in tables 2, 3, & 4 reveal that the diagnostic
performances are very much affected by the model selection. The DNN model with
the best suitable architecture for the given dataset gives $CA$ up to almost
100% whereas other methods with pre-selected architecture fail to perform
well.

  2. 2.

Considering SVM [35] as the baseline diagnostic method, We evaluate the
transfer improvement ($TI$) in term of average $CA$ for the dataset T1, T2,
T3, & T4 separately. If the average $CA$ is denoted as $\overline{CA}$, the
$TI$ is defined as $TI=\overline{CA}-\overline{CA}_{b}$, where
$\overline{CA}_{b}$ is the average $CA$ by SVM. The $TI$ graph shown in Fig. 6
shows the performance improvement of the proposed framework in comparison with
the state-of-the-art methods and the baseline method ‘SVM’.

  3. 3.

The performance comparison between EvoN2N [26] and the proposed method shows
that architecture optimization is greatly affected by the guided sampling with
policy gradient framework.

  4. 4.

Fig. 7 demonstrate the classification performance by confusion chart matrices
for one of the dataset (T4-L1: table 4). Classifications with 100% accuracies
are highlighted by blackened diagonal elements where for other cases, diagonal
elements are highlighted by gray shade.

  5. 5.

The comparison between EvoDCNN [25], EvoN2N [26], & the proposed GS-EvoN2N
reveal that the DNN model with the best architecture performs better than the
CNN model for fault diagnosis applications with the segmented dataset
(described in section 5.2.

###  5.6 Complexity Analysis

The worst complexities in one iteration of the entire algorithm 1 are
contributed by (i) fitness evaluation of the DNN model and (ii) the non-
dominated sorting. The complexity of the fitness evaluation of DNN is mainly
contributed by parameter optimization by L-BFGS which is $O(N_{I}*n^{2})$,
where $n\&N_{I}$ be the total number of parameters and number of iterations
required to fine-tune the DNN model. The non-dominated sorting algorithm has a
complexity of $O(MN_{p}^{2})$, where $M\&N_{p}^{2}$ be the number of
objectives and the population size respectively. Since $M$ is very small
compared to $N_{I}$, therefore, the time complexity for GS-EvoDNN with
population size $N_{p}$ is given by $O(N_{I}N_{p}n^{2})$, where $n=$ total
number of parameters in one model and $N_{I}$ = number of iterations taken for
model training.

##  6 Conclusions

In this article, we have formulated a guided sampling-based evolutionary
algorithm for DNN architecture search. The proposed framework uses the concept
of policy gradient to sample the new population to force the evolution towards
the maximization of classification performance. The best model obtained at any
generation is transferred to the next generation to initialize the model
evaluation which makes the entire algorithm faster. Therefore, this method is
very good in terms of faster evolution and faster convergence while ensuring
global convergence by update policy of mean and variance. The validation using
dataset under various cases from Air Compressor data, CWRU data, and PBU data
prove that the proposed framework is capable to obtain the best model to get
diagnostic performance almost up to 100% accuracy. This method can also be
employed for the architecture optimization of the CNN model with image
classification applications.

## References

  * [1] S. Nandi, H. A. Toliyat, and X. Li, “Condition monitoring and fault diagnosis of electrical motors—a review,” _IEEE Transactions on Energy Conversion_ , vol. 20, no. 4, pp. 719–729, Dec 2005.
  * [2] A. Siddique, G. S. Yadava, and B. Singh, “A review of stator fault monitoring techniques of induction motors,” _IEEE Transactions on Energy Conversion_ , vol. 20, no. 1, pp. 106–114, March 2005.
  * [3] S. Yin, S. X. Ding, X. Xie, and H. Luo, “A review on basic data-driven approaches for industrial process monitoring,” _IEEE Transactions on Industrial Electronics_ , vol. 61, no. 11, pp. 6418–6428, 2014.
  * [4] X. Chen, S. Wang, B. Qiao, and Q. Chen, “Basic research on machinery fault diagnostics: Past, present, and future trends,” _Front. Mech. Eng._ , vol. 13, p. 264–291, 2018.
  * [5] Z. Chen, F. Han, L. Wu, J. Yu, S. Cheng, P. Lin, and H. Chen, “Random forest based intelligent fault diagnosis for pv arrays using array voltage and string currents,” _Energy conversion and management_ , vol. 178, pp. 250–264, 2018.
  * [6] A. K. Sharma, V. Singh, N. K. Verma, and J. Liu, “Condition based monitoring of machine using mamdani fuzzy network,” in _2018 Prognostics and System Health Management Conference (PHM-Chongqing)_ , Oct 2018, pp. 1159–1163.
  * [7] Y. Qi, C. Shen, D. Wang, J. Shi, X. Jiang, and Z. Zhu, “Stacked sparse autoencoder-based deep network for fault diagnosis of rotating machinery,” _IEEE Access_ , vol. 5, pp. 15 066–15 079, 2017.
  * [8] R. Zhao, R. Yan, Z. Chen, K. Mao, P. Wang, and R. X. Gao, “Deep learning and its applications to machine health monitoring,” _Mechanical Systems and Signal Processing_ , vol. 115, pp. 213 – 237, 2019.
  * [9] S. J. Pan, I. W. Tsang, J. T. Kwok, and Q. Yang, “Domain adaptation via transfer component analysis,” _IEEE Transactions on Neural Networks_ , vol. 22, no. 2, pp. 199–210, Feb 2011.
  * [10] M. Long, J. Wang, G. Ding, S. J. Pan, and P. S. Yu, “Adaptation regularization: A general framework for transfer learning,” _IEEE Transactions on Knowledge and Data Engineering_ , vol. 26, no. 5, pp. 1076–1089, 2014.
  * [11] Y. Ganin, E. Ustinova, H. Ajakan, P. Germain, H. Larochelle, F. Laviolette, M. March, and V. Lempitsky, “Domain-adversarial training of neural networks,” _Journal of Machine Learning Research_ , vol. 17, no. 59, pp. 1–35, 2016.
  * [12] W. Lu, B. Liang, Y. Cheng, D. Meng, J. Yang, and T. Zhang, “Deep model based domain adaptation for fault diagnosis,” _IEEE Transactions on Industrial Electronics_ , vol. 64, no. 3, pp. 2296–2305, March 2017.
  * [13] L. Wen, L. Gao, and X. Li, “A new deep transfer learning based on sparse auto-encoder for fault diagnosis,” _IEEE Transactions on Systems, Man, and Cybernetics: Systems_ , vol. 49, no. 1, pp. 136–144, Jan 2019.
  * [14] L. Guo, Y. Lei, S. Xing, T. Yan, and N. Li, “Deep convolutional transfer learning network: A new method for intelligent fault diagnosis of machines with unlabeled data,” _IEEE Transactions on Industrial Electronics_ , vol. 66, no. 9, pp. 7316–7325, Sep. 2019.
  * [15] D. Wei, T. Han, F. Chu, and M. J. Zuo, “Weighted domain adaptation networks for machinery fault diagnosis,” _Mechanical Systems and Signal Processing_ , vol. 158, p. 107744, 2021.
  * [16] A. K. Sharma and N. K. Verma, “Quick learning mechanism with cross-domain adaptation for intelligent fault diagnosis,” 2021.
  * [17] G. Wang, J. Qiao, J. Bi, W. Li, and M. Zhou, “Tl-gdbn: Growing deep belief network with transfer learning,” _IEEE Transactions on Automation Science and Engineering_ , vol. 16, no. 2, pp. 874–885, April 2019\.
  * [18] X. He, K. Zhao, and X. Chu, “Automl: A survey of the state-of-the-art,” _Knowledge-Based Systems_ , vol. 212, p. 106622, 2021.
  * [19] J. Bergstra and Y. Bengio, “Random search for hyper-parameter optimization,” _J. Mach. Learn. Res._ , vol. 13, pp. 281–305, Feb. 2012.
  * [20] F. Hutter, H. H. Hoos, and K. Leyton-Brown, “Sequential model-based optimization for general algorithm configuration,” in _Learning and Intelligent Optimization_ , C. A. C. Coello, Ed. Berlin, Heidelberg: Springer Berlin Heidelberg, 2011, pp. 507–523.
  * [21] B. Baker, O. Gupta, N. Naik, and R. Raskar, “Designing neural network architectures using reinforcement learning,” _CoRR_ , vol. abs/1611.02167, 2016.
  * [22] S. M. R. Loghmanian, H. Jamaluddin, R. Ahmad, R. Yusof, and M. Khalid, “Structure optimization of neural network for dynamic system modeling using multi-objective genetic algorithm,” _Neural Computing and Applications_ , vol. 21, no. 6, pp. 1281–1295, 2012.
  * [23] C. Wang, C. Xu, X. Yao, and D. Tao, “Evolutionary generative adversarial networks,” _IEEE Transactions on Evolutionary Computation_ , vol. 23, no. 6, pp. 921–934, 2019.
  * [24] Y. Sun, B. Xue, M. Zhang, and G. G. Yen, “A particle swarm optimization-based flexible convolutional autoencoder for image classification,” _IEEE Transactions on Neural Networks and Learning Systems_ , vol. 30, no. 8, pp. 2295–2309, Aug 2019.
  * [25] Y. Sun, B. Xue, M. Zhang, and G. G. Yen, “Evolving deep convolutional neural networks for image classification,” _IEEE Transactions on Evolutionary Computation_ , vol. 24, no. 2, pp. 394–407, 2020.
  * [26] A. K. Sharma and N. K. Verma, “Transfer learning based evolutionary deep neural network for intelligent fault diagnosis,” 2021.
  * [27] H. Liu, K. Simonyan, and Y. Yang, “Darts: Differentiable architecture search,” in _International Conference on Learning Representations_ , 2019\.
  * [28] Z. Yang, Y. Wang, X. Chen, B. Shi, C. Xu, C. Xu, Q. Tian, and C. Xu, “Cars: Continuous evolution for efficient neural architecture search,” in _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition_ , 2020, pp. 1829–1838.
  * [29] E. Real, A. Aggarwal, Y. Huang, and Q. V. Le, “Regularized evolution for image classifier architecture search,” _Proceedings of the AAAI Conference on Artificial Intelligence_ , vol. 33, no. 01, pp. 4780–4789, Jul. 2019. [Online]. Available: https://ojs.aaai.org/index.php/AAAI/article/view/4405
  * [30] K. Deb, A. Pratap, S. Agarwal, and T. Meyarivan, “A fast and elitist multiobjective genetic algorithm: NSGA-II,” _IEEE Transactions on Evolutionary Computation_ , vol. 6, no. 2, pp. 182–197, 2002.
  * [31] Z. Lu, I. Whalen, Y. Dhebar, K. Deb, E. D. Goodman, W. Banzhaf, and V. N. Boddeti, “Multiobjective evolutionary design of deep convolutional neural networks for image classification,” _IEEE Transactions on Evolutionary Computation_ , vol. 25, no. 2, pp. 277–291, 2021.
  * [32] G. E. Hinton and R. R. Salakhutdinov, “Reducing the dimensionality of data with neural networks,” _Science_ , vol. 313, no. 5786, pp. 504–507, 2006\.
  * [33] Y. Bengio, P. Lamblin, D. Popovici, and H. Larochelle, “Greedy layer-wise training of deep networks,” in _Advances in Neural Information Processing Systems 19_ , B. Schölkopf, J. C. Platt, and T. Hoffman, Eds. MIT Press, 2007, pp. 153–160.
  * [34] H. Su and K. T. Chong, “Induction machine condition monitoring using neural network modeling,” _IEEE Transactions on Industrial Electronics_ , vol. 54, no. 1, pp. 241–249, 2007.
  * [35] A. Widodo and B.-S. Yang, “Support vector machine in machine condition monitoring and fault diagnosis,” _Mechanical Systems and Signal Processing_ , vol. 21, no. 6, pp. 2560–2574, 2007.
  * [36] X. Yan and M. Jia, “A novel optimized svm classification algorithm with multi-domain feature and its application to fault diagnosis of rolling bearing,” _Neurocomputing_ , vol. 313, pp. 47–64, 2018.
  * [37] S. D. Juan Jose, et al., “Multifault diagnosis method applied to an electric machine based on high-dimensional feature reduction,” _IEEE Transactions on Industry Applications_ , vol. 53, no. 3, pp. 3086–3097, 2016.
  * [38] X. Li, W. Zhang, and Q. Ding, “Cross-domain fault diagnosis of rolling element bearings using deep generative neural networks,” _IEEE Transactions on Industrial Electronics_ , vol. 66, no. 7, pp. 5525–5534, July 2019\.
  * [39] B. Zoph, V. Vasudevan, J. Shlens, and Q. V. Le, “Learning transferable architectures for scalable image recognition,” in _Proc. IEEE Comput. Soc. Conf. Comput. Vis. Pattern Recognit._ , 2018, pp. 8697–8710.
  * [40] A. Hundt, V. Jain, and G. D. Hager, “sharpdarts: Faster and more accurate differentiable architecture search,” _CoRR_ , vol. abs/1903.09900, 2019. [Online]. Available: http://arxiv.org/abs/1903.09900
  * [41] K. Kandasamy, W. Neiswanger, J. Schneider, B. Póczos, and E. P. Xing, “Neural architecture search with bayesian optimisation and optimal transport,” in _Proceedings of the 32nd International Conference on Neural Information Processing Systems_ , ser. NIPS’18, 2018, p. 2020–2029.
  * [42] J. S. Bergstra, R. Bardenet, Y. Bengio, and B. Kégl, “Algorithms for hyper-parameter optimization,” in _Advances in Neural Information Processing Systems 24_ , J. Shawe-Taylor, R. S. Zemel, P. L. Bartlett, F. Pereira, and K. Q. Weinberger, Eds. Curran Associates, Inc., 2011, pp. 2546–2554.
  * [43] H. Pham, M. Guan, B. Zoph, Q. Le, and J. Dean, “Efficient neural architecture search via parameters sharing,” in _International Conference on Machine Learning_. PMLR, 2018, pp. 4095–4104.
  * [44] R. Luo, F. Tian, T. Qin, E. Chen, and T.-Y. Liu, “Neural architecture optimization,” in _Advances in Neural Information Processing Systems_ , S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett, Eds., vol. 31. Curran Associates, Inc., 2018.
  * [45] B. Zoph and Q. V. Le, “Neural architecture search with reinforcement learning,” _arXiv preprint arXiv:1611.01578_ , 2016.
  * [46] J. Sun, X. Liu, T. Bäck, and Z. Xu, “Learning adaptive differential evolution algorithm from optimization experiences by policy gradient,” _IEEE Transactions on Evolutionary Computation_ , vol. 25, no. 4, pp. 666–680, 2021\.
  * [47] Y. Chen, G. Meng, Q. Zhang, S. Xiang, C. Huang, L. Mu, and X. Wang, “Renas: Reinforced evolutionary neural architecture search,” in _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition_ , 2019, pp. 4787–4796.
  * [48] Y. Sun, H. Wang, B. Xue, Y. Jin, G. G. Yen, and M. Zhang, “Surrogate-assisted evolutionary deep learning using an end-to-end random forest-based performance predictor,” _IEEE Transactions on Evolutionary Computation_ , vol. 24, no. 2, pp. 350–364, 2019.
  * [49] R. J. Williams, “Simple statistical gradient-following algorithms for connectionist reinforcement learning,” _Machine Learning_ , vol. 8, no. 3-4, p. 229–256, May 1992.
  * [50] R. Sutton and A. Barto, _Reinforcement Learning: An Introduction, second edition_ , ser. Adaptive Computation and Machine Learning series. MIT Press, 2018.
  * [51] J. Nocedal and S. J. Wright, _Large-Scale Unconstrained Optimization_. New York, NY: Springer New York, 2006, pp. 164–192.
  * [52] N. K. Verma, R. K. Sevakula, S. Dixit, and A. Salour, “Intelligent condition based monitoring using acoustic signals for air compressors,” _IEEE Transactions on Reliability_ , vol. 65, no. 1, pp. 291–309, March 2016\.
  * [53] C. Lessmeier, J. Kimotho, D. Zimmer, and W. Sextro, “Condition monitoring of bearing damage in electromechanical drive systems by using motor current signals of electric motors: A benchmark data set for data-driven classification,” _European Conf., PHM Society, Bilbao (Spain)_ , vol. 3, no. 1, 2016.
  * [54] W. A. Smith and R. B. Randall, “Rolling element bearing diagnostics using the Case Western Reserve University data: A benchmark study,” _Mechanical Systems and Signal Processing_ , vol. 64, pp. 100–131, 2015.