AI-Based Predictive Maintenance for Rotor Crack Fault Diagnosis for Variable-Speed Machines Using Transfer Learning

Abstract

Fatigue-related ‘rotor crack’ can cause catastrophic failure if neglected. Thus, IoT-enabled AI-based predictive maintenance for fault detection and diagnosis is explored. Training and testing AI models under similar conditions improves their prediction performance. On variable speed machines, loss of performance occurs when the testing speed differs from the training speed. This research addresses significant performance loss issues using convolutional neural network (CNN)-based transfer learning models. The main causes of performance loss are domain shift, overfitting, data class imbalance, low fault data availability, and biassed prediction. All the above difficult issues make CNN-based fault prediction systems function badly under varying operating conditions. The proposed methodology addresses all domain adaptation challenges. The proposed methodology was tested by collecting vibration data from an experimental rotor system under varied operating conditions. The proposed methodology outperforms classical machine learning (ML) and deep learning (DL) models, overcoming the overfitting issue with optimised hyperparameters, achieving a prediction accuracy of 99.5%. Under varying operating conditions, it outperforms with a prediction accuracy of 93.2%, and in the ‘data class imbalanced’ scenario, the maximal transfer learning capability achieved was 84.4% with the highest F1-Score. Thus, CNN-based transfer learning enables industrial variable speed machines diagnose rotor crack flaws better than ML and DL models.

1. Introduction

In the 1970s, industrial machine failures, such as power turbine rotor fatigue failures in the USA, caused enormous asset, production, financial, and environmental losses [1,2,3,4,5]. Since then, extensive research has been conducted on the predictive maintenance of rotor fatigue crack failure to identify, locate, and notify about the failure of turbo machines. Traditionally, a crack is identified using vibration-based methods, which are sub-classified as signal- and model-based methods. The main issue with these traditional methods is that they are human-centric, i.e., they involve humans for the analysis and interpretation of hand-crafted features [6,7].

An extensive review of cracked rotor dynamics has been provided in [5], where the author identifies that Meyer J [8] established that the reduction of motion to linear equations with periodic coefficients, as established by many researchers, is merely an approximation. It also showed that the first work on using the energy release rate from the fracture mechanism was by Dimarogonas [9,10], which was further continued by Dimarogonas et al. [10]. Grabowski [11] developed a model with a transverse crack and concluded that the crack causes 1× and 2× of rotating-speed-related vibration. This is independent of the size and position of the imbalance; however, the phase in the response vibration is an important indicator of a crack. Additionally, a gaping crack causes exclusively 2× primary vibration. The same results were obtained by [5]. Muszynska [5,12] modelled local stiffness changes for a gaping crack with imbalance and gravity excitation and found 1× primary vibration increasing with the fault. She also discussed the causes of it, including initial asymmetry and damping of the rotor [5]. Papadopoulos [10] conducted an extensive survey to explore the model developed by Dimarogonas [13]. The contributions of Darpe et al. [14], Sekhar and Prabhu [15], Gounaris and Dimarogonas [16], Mayes and Davies [17], Bachschmid and Tanzi [18], and Chasalevris and Papadopoulos [19] are appreciated for their contributions to refining the crack identification model. Model-based methods require higher mathematical skills and expertise in rotor dynamics. In addition, analytical or numerical models can replicate cracked rotors; however, these methods are time-consuming and do not accurately predict or prevent catastrophic failure in a timely manner. This is because fatigue failures progress rapidly and are not detected by the existing machine protection systems used in these machines. Therefore, there is a need for an artificial-intelligence-based online and continuous monitoring system on turbo machinery to overcome the challenges faced by traditional signal- and model-based fault identification and diagnosis methods. As per Harvard Business Review [20], industries have started using AI technologies in predictive maintenance for industries. Market research reports indicate that the predictive maintenance industry is expected to grow at a rate exceeding USD 14.11 billion by 2028 [21].

Non-traditional predictive maintenance systems still need manual intervention to perform hand-crafted feature design, feature extraction/selection, model training [22], and pre-processing techniques. An inherent limitation of non-traditional predictive maintenance systems that employ machine learning and other methodologies is that they require appropriate domain knowledge for extracting crack-related features from the acquired data. Hence, automatic feature extraction capabilities were developed in a DL-based convolutional neural network (CNN). CNN has been explored in recent research works on machinery fault diagnosis, including bearings, gearboxes, motors, and rotor mass imbalance [23,24,25,26,27,28,29]. Zhao et al. [30] have developed a model to distinguish between shaft misalignment and cracks, which share similar dynamic vibration characteristics. The blade crack detection was explored by Shen et al. [31]. However, in industrial machines, rotor crack faults involve complex rotor dynamics, and research studies regarding rotor crack detection and diagnosis using CNN-based deep learning are scarce.

Researchers could establish CNN’s advantages in machinery fault diagnostics by manually tuning hyperparameters [23,24,25]. Due to the complexity of machinery fault diagnostic data, manually adjusting hyperparameters to improve prediction accuracy is difficult and time-consuming. As hyperparameters directly influence CNN performance, hyperparameter tuning has become a critical intrinsic problem that must be addressed for successful CNN performance. The present research addresses the inherent challenges of the CNN, such as overfitting [32] and hyperparameter optimisation [33]. Recently, the genetic algorithm (GA) has been explored in 1D applications, including biomedical, structural health monitoring, audio, and speech detection, among others [34]. The authors [29,35] have extended the research on CNN hyperparameter optimisation into machinery fault diagnosis. Among them, [29] carried out extensive research on the impact of hyperparameters and the position of the dropout layer on CNN’s performance. They have effectively addressed the hyperparameter optimisation issue using the GA and studied the performance of CNN models by positioning the dropout layer in various architectures. This research builds upon the work of [29] and further extends it by exploring domain-invariant feature learning.

The fault prediction algorithms face another challenge: biassed prediction due to data imbalance. This means the amount of healthy data is more than that of faulty data. Machinery diagnosis also suffers from the issue of the nature of the source data, which is multi-class and imbalanced [6]. Various researchers have addressed this issue in different fields [36,37]. Hence, to tackle class-imbalanced machinery fault data, the present research explores the Synthetic Minority Over-sampling Technique (SMOTE), a method introduced by Chawla et al. [38], which has proven to be the best for data-level class balancing. The research study also observed that fault detection and diagnosis systems have been developed to automatically detect, diagnose, and assess the equipment fault severity; hence, the intelligent system/model/approach developed and trained on the test rig cannot be deployed directly on other similar equipment without considering the varying operational conditions. Conventional methods for intelligent crack fault diagnostics assume that the distribution of data in both the labelled source domain and the unlabelled target domain is identical. However, this might not always hold true in practical applications. It leads to a poor generalisation of the deployed machine learning algorithm, commonly known as the domain shift issue.

Recently, domain adaptation (DA) methods have been used to solve the issue of change in feature distribution, which is called domain shift. Zhang et al. [39] proposed a Convolution Neural Network with Training Interference (TICNN) model in which the CNN structure was developed with two training interferences. They developed it to diagnose bearing faults in signals that come from noisy environments. A robust fault diagnosis method has been proposed for the transfer learning technique of improved joint distribution adaptation (IJDA) to systematically synchronise both datasets’ marginal and conditional distributions [40]. Guo et al. [41] introduced a transfer learning method that increases domain identification error and decreases the probability distribution distance. This method was based on a 1D-CNN module. A deep CNN has been framed and implemented for gear fault detection [42]. A transfer learning framework based on a pre-trained CNN has been utilised in another research work to detect gear and bearing faults [43]. The literature review reveals that bearing faults [41,44,45,46,47,48,49,50,51], gear faults [41,42,52,53,54,55,56], and common faults such as imbalance, misalignment, bearing, and gearbox faults have been explored using domain adaptation. The research study indicates that rotor crack faults have been a critical issue for industrial applications under varying operating speed conditions. To the best of the authors’ knowledge, the study reported on the use of domain adaptation techniques for crack fault detection and diagnosis using domain-invariant methods is scarce.

It is essential to address the gaps of fault complexity, data scarcity, class imbalance, and algorithmic optimisation to enhance fault detection processes in industrial applications. Therefore, this research explores rotor cracks by addressing the industrial challenges associated with the machinery fault diagnosis system. It investigates the use of CNN-based deep learning in the automated diagnosis of machinery faults, eliminating the need for human intervention in the feature-extraction process. Additionally, it addresses CNN’s inherent issues of hyperparameter optimisation and the model’s overfitting. Furthermore, a single fault diagnosis system adaptable to variable operating conditions is explored using the domain-invariant feature learning of Adversarial Discriminator Domain Adaptation (ADDA), and the limitations of the 1D-CNN are addressed within this framework. The present work proposes a domain-invariant feature learning architecture that addresses data class imbalance and hyperparameter issues for detecting and diagnosing rotor crack faults in variable-speed machines. Furthermore, its efficacy has been examined through various case studies.

The research paper is organised as follows. Section 2 covers the proposed methodology for diagnosing rotor crack faults in variable-speed machines. It provides details of the experimental rotor rig setup and data generation methods employed in the research. Section 3 focuses on the results and discusses the research outcomes. Finally, the paper concludes with the findings, benefits, and industrial contribution to machinery fault diagnosis.

2. Materials and Methods

2.1. ADDA (Adversarial Discriminator Domain Adaptation)

The challenge for existing machinery fault diagnosis methodologies is to apply past learning when new circumstances arise due to changes in operational conditions, which causes the domain shifting problem. The domain shift problem occurs when classifiers incorrectly assign attributes from the source domain to the target domain. The authors [57] reviewed various methods for feature learning to address this problem. Among them, domain-invariant feature learning has the potential to categorise features more effectively than other methods of domain adaptation [57]. In domain-invariant feature learning, Generative Adversarial Networks (GANs) have recently gained the focus of research. They have the ability to quickly adapt the target domain to the specific conditions of a given source data by generating similar domain data. Discriminators and generators are used to train Generative Adversarial Networks (GANs) in a competitive manner. Several adversarial GAN models have emerged to tackle domain discrepancy, which causes the domain shift problem.

Tzeng et al. [58] made generalisations about adversarial models, and with these generalisations of adversarial techniques, three design choices are available: generative or discriminative base models, weight tying or untying, and adversarial learning objectives. Furthermore, the authors [58] used a discriminative model with untied weights and the typical GAN loss, as illustrated in Figure 1. The next step is to tune the model to fit the target domain. The goal of adversarial adaptive approaches [58] is to minimise the difference between the distributions of source and target mappings, $M_s\left(X_s\right)$ and $M_t\left(X_t\right)$, by regularising the learning process of these mappings.

Figure 1. ADDA framework [59].

Research [58] demonstrates that the inverted label GAN loss achieves the following optimisation. $X_s$ and $Y_s$ are source data and labels and are derived from a source domain distribution $p_s\left(x,y\right)$, while $X_t$ is a target distribution $p_t\left(x,y\right)$ with no label observations. The aim is to learn a classifier $C_t$ and target representation $M_t$ that can accurately classify target data into one of K categories at test time, even in the absence of in-domain annotations. The target cannot be directly supervised; thus, domain adaptation trains a source representation mapping, $M_s$, and a source classifier, $C_s$, then adapts that model for the target domain. This can be carried out in adversarial adaptive learning by reducing the distribution gap between the source and target mapping of $M_s(X_s$) & $M_t\left(X_t\right)$ thus, the target classifier can be eliminated, such as $C$ = $C_s$ = $C_t$.

The function ${\mathcal{L}}_{{adv}_D}$ is a discriminator’s standard classification loss, ${\mathcal{L}}_{\mathit{c}\mathit{l}\mathit{s}}$ The classifier loss, and $C$ = $C_s$ = $C_t$.

$$\underset{M_s,C}{\min }{\mathcal{L}}_{cls}\left(X_s,Y_s\right)=-{\mathbb{E}}_{\left(x_s,y_s\right)~\left(X_s,Y_s\right)}\sum _{k=1}^K{1}_{\left[k=y_s\right]}\log C\left(M_s\left(X_s\right)\right)$$

(1)

″D″ is the domain discriminator; it is optimised through standard supervised loss, ${\mathcal{L}}_{{\mathrm{a}\mathrm{d}\mathrm{v}}_{\mathrm{D}}}\left({\mathrm{X}}_{\mathrm{s}},{\mathrm{X}}_{\mathrm{t}}{,\mathrm{M}}_{\mathrm{s}}{,\mathrm{M}}_{\mathrm{t}}\right)$, and the labels show their origin domain:

$$\underset{D}{\min }{\mathcal{L}}_{{adv}_D}\left(X_s,X_t{,M}_s{,M}_t\right)=-{\mathbb{E}}_{x_s~X_s}[\log D\left(M_s\left(X_s\right)\right)]-{\mathbb{E}}_{x_t~X_T}[\log \left(1-D\left(M_s\left(X_s\right)\right)\right)]$$

(2)

$$\underset{M_t}{\min }{\mathcal{L}}_{{adv}_M}\left(X_s,X_t,D\right)=-{\mathbb{E}}_{x_t~X_t}[\log D\left(M_t\left(X_t\right)\right)]$$

(3)

Without weight sharing, the target domain cannot access labels, which means that the target model may quickly reach a degenerate solution due to improper training and initialisation. Therefore, to train adversarially, one must alter the source model and then use it to initialise the target representation space.

2.2. Phase 1—Data Generation and Pre-Processing

The flow chart of the proposed methodology is shown in Figure 2, and technical details are shown in Figure 3a,b. In the first phase, data generation and pre-processing were carried out. In the second phase, adversarial learning was implemented, and in the third phase, testing of the target domain data was performed.

Figure 2. Flow chart of the proposed methodology.

Figure 3. (a) Data generation & Pretraining of Proposed methodology. (b) Adversarial Adaptation & Testing of Proposed methodology.

2.2.1. Generating Rotor Rig Data and Pre-Processing

Acceleration sensors acquire rotor health data from the experimental test setup, as shown in Figure 3a,b. The generated data are further utilised according to the proposed methodology. A reference source domain has utilised one set of operational speed data samples, while the other set of speed data is considered samples for the target domain. In order to assess class balance, the allocation of samples in the source and target datasets was analysed. Once the class is balanced, the hyperparameters are fine-tuned by the evolutionary algorithm. To correct the issue of data class imbalance, SMOTE is applied to data samples from either the source or target domains. Once the samples have been balanced, the hyperparameters are optimised, as demonstrated in Figure 3a,b.

2.2.2. GA-Based Hyper Parameter Optimisation

The genetic algorithm tunes 1D-CNN hyperparameters directly, utilising the time waveform as input data. Figure 4 illustrates the 1D-CNN, which incorporates convolutional, batch normalisation, pooling, and dropout layers.

Figure 4. The 1D-CNN general architecture.

The CNN hyperparameters, including the dropout layer in the final feature-extraction layer [29], have been genetically optimised to maximise the performance of 1D-CNN, as shown in Figure 5. The 1D-CNN design consists of 5 convolutional layers, 2 hidden layers, and a sigmoid classifier.

Figure 5. GA-based hyperparameter optimisation 1D-CNN [27].

Figure 5 illustrates how GA optimisation creates 1D-CNN populations using randomly generated hyperparameters. After that, accuracy is computed for every output forecast, and the population record is arranged from high to low based on fitness value. To maintain population diversity and enhance the genetic algorithm’s convergence with newly hyperparameterised settings that have been fitness-tested, randomly generated hyperparameters have been introduced to facilitate mutation and the creation of new offspring. The genetic algorithm stops when the forecasted accuracy equals the fitness score of the new offspring and provides the optimised 1D-CNN hyperparameters. The genetic algorithm terminates generation and preserves the hyperparameters if the fitness score is at a maximum; otherwise, evolution continues until convergence. Figure 3a,b show how optimised hyperparameters are used in the second and third phases of the proposed methodology to maximise prediction accuracy.

2.3. Phase 2—Adversarial Learning Implementation

Figure 3b illustrates the second phase of the proposed process, which involves pre-training the source encoder and performing adversarial learning. The ADDA receives data from both the source and target domains for the respective encoders. Initially, the source encoder is pre-trained using a source classifier network to classify the data. Furthermore, a discriminator network is employed to mitigate domain discrepancies through adversarial learning. Genetically optimised 1D-CNN hyperparameters extract domain-invariant features, which are a part of the ADDA’s architecture.

2.3.1. Training of Task Network with Source Encoder

The classifier network is trained to classify the labelled source domain data during the task network’s training, utilising the source encoder domain adaptation phase. Adjusting the encoder weights may decrease the classifier loss and boost the classifier’s performance via backpropagation.

2.3.2. Adversarial Learning Process

In adversarial learning, the target encoder competes with a discriminator network to classify the data from both the source and target domains. The source encoder’s weights are fixed, while the target encoder alters weights depending on the discriminator GAN loss. The discriminator identifies domain-related features by adjusting the weights of the target encoder based on the discriminator’s GAN loss. Thus, the fault classification features are preserved, and only the domain shift-related features, which are related to varying operating conditions, are identified and equalised. This enables the model to predict the fault under any operational condition. The target encoder weighs the optimisation training process to decrease domain shift is depicted in Figure 3a,b.

2.4. Phase 3—Testing of Target Domain

The source classifier and a learned target encoder have been used to test target domain samples. Employing ADDA with GO-1D-CNN enables the optimisation of GAN loss for domain discrepancy, which decreases domain shift by capturing domain-invariant features. Further usage of an unaltered classifier ensures classification capabilities are not affected for both source and target domain samples. In the proposed framework, SMOTE is not applied to the raw test data of the target domain. It is only used during the training stage to address the sample scarcity and class imbalance that occur when constructing the feature space. In ADDA, domain alignment is performed at the representation level, where the target encoder learns to map target samples into a feature distribution that is consistent with the source encoder. SMOTE is therefore applied to the target feature embeddings during training, not on unseen target test samples. This enables us to provide a more balanced representation to the discriminator and to prevent biassed decision boundaries while preserving the natural distribution of real target samples in testing. Table 1 and Table 2 present the source and target domain data, as well as the operating speeds at which performance is evaluated.

Table 1. Data Generated from Experimental Test Rig.

Description of Test Rig Rotor Condition		Experimental Test Rig’s Rotor Crack Fault Data
		Class-Balanced Data		Class Imbalanced Data
		Source	Target	Source	Target
S_HL	Healthy Shaft	100	100	85	10
S_CRD_1MM	Shaft Crack depth 1 mm	100	100	70	25
S_CRD_2MM	Shaft Crack depth 2 mm	100	100	55	40
S_CRD_3MM	Shaft Crack depth 3 mm	100	100	40	55
S_CRD_4MM	Shaft Crack depth 4 mm	100	100	25	70
S_CRD_5MM	Shaft Crack depth 5 mm	100	100	10	85
	Total data samples	600	600	285	285

Table 2. Operating speeds of the rotor rig used for the DA task.

Domain Adaptation Task	Domain
	Source Machine Speed (RPM)	Target Machine Speed (RPM)
DA1500–1750	1500	1750
DA1500–2000	1500	2000
DA1750–1500	1750	1500
DA1750–2000	1750	2000
DA2000–1500	2000	1500
DA2000–1750	2000	1750

2.5. Experimental Setup

The experimental setup is shown in Figure 6. The rotor rig experimental setup comprises the rotor assembly, which is equipped with a motor speed controller and a drive motor. The rotor assembly has acceleration and vibration sensors designed to monitor vibration. The experimental setup comprises a motor with a power of 1/6 hp and a rotor system consisting of a shaft with a 10 mm diameter, a disc installed in the middle, and ball bearings 500 mm apart supporting the shaft’s ends. Accelerometers that record data are mounted on the bearing housing, and the flexible coupling is used to connect the motor and shaft. The disc has four holes spaced at right angles to each other. An acceleration sensor with a sensitivity of 100 mV/g is used to collect the vibration time waveform, which is then processed with the NI data card 9230. A 50 kHz vibration time waveform is recorded for two seconds, and many vibration time waveform signals are recorded at 1500 RPM, 1750 RPM, and 2000 RPM. The collected data is then divided into 2000 data points per sample.

Figure 6. The experimental setup.

The cracks were made using wire cutting, with a 0.2 mm width, and their depths were varied from 1 mm to 5 mm. This range was chosen to reflect practical levels of rotor fault severity. In total, six health states were considered: one healthy shaft with no crack and five cracked shafts with depths from 1 mm up to 5 mm. These crack levels are commonly used in vibration-based condition monitoring studies and provide fault signatures that are well-suited for further classification and adaptation. For all six health statuses, 600 samples are collected, 100 samples for each class/condition. For the data class-balanced condition, 600 samples were collected for each domain, which includes both the source and target domains. However, linear class imbalance has been implemented for the class-imbalanced condition, resulting in the collection of 285 samples for each domain, which includes both the source and target domains. Table 1 presents the samples used in the source and target domains for both balanced and imbalanced data class conditions. A similar procedure is repeated to generate target domain data, as illustrated in Table 2.

The frequency spectrum and time waveform details have been extracted for machine learning algorithms’ training and testing data. The acceleration time waveform has been integrated to derive velocity and displacement data. A total of 108 features have been extracted from displacement, velocity, and acceleration spectra and time waveforms, and 36 features have been extracted from each measurement. From the research [6,59], the features considered are summarised in Table 3.

Table 3. Acceleration, velocity, and displacement features used in machine learning algorithms [6,59].

Domain	Features
Frequency (X RPM)	1/3	2/3	4/3	5/3	1	2
	3	4	5	6	7	8
	9	10	11	12	13	14
	15	16	17	18
Time	mean	standard deviation	Variance	3rd moment	5th central moment	6th central moment
	8th moment	Entropy	RMS	Skewness	kurtosis	Crest factor
	Maximum	Minimum

3. Results and Discussion

To investigate the necessity of domain adaptation capabilities when dealing with varying operating conditions, as well as other problems inherent to CNN, this section presents three distinct studies analysing the experimental data. The performance evaluation is conducted by comparing machine learning (ML), deep learning (DL), traditional transfer learning algorithms, and domain-invariant feature learning approaches. The ML algorithms used in this study include Logistic Regression (LR), K-Nearest Neighbour (KNN), Classification and Regression Tree (CART), Support Vector Machine (SVM), Random Forests (RF), and Artificial Neural Network (ANN). The DL models considered are a manually tuned one-dimensional convolutional neural network (MTH-1D-CNN) and a genetic-algorithm-optimised 1D-CNN (GO-1D-CNN). The traditional transfer learning methods evaluated comprise Joint Distribution Adaptation (JDA), Balanced Distribution Adaptation (BDA), and Easy Transfer Learning (EasyTL). Finally, the domain-invariant feature learning approaches include Domain-Adversarial Neural Networks (DANN), Deep Correlation Alignment (DeepCORAL), and the proposed methodology. By comparing different algorithms, the effectiveness of the proposed methodology for rotor crack detection and diagnostic systems in industrial machines is evaluated.

3.1. Study 1: Evaluating Performance of ADDA and 1D-CNN with Manually Tuned Hyperparameters

Study 1 evaluates the proposed methodology’s variable-speed rotor crack detection and diagnosis capability. As shown in Figure 3a,b, Adversarial Discriminative Domain Adaptation is utilised on different operating speeds to address the domain shift problem. Six conventional machine learning methods and a 1D-CNN model have been evaluated for domain adaptation by directly utilising the trained model on a reference speed against different operating speeds, as shown in Table 2. Figure 7 shows that the DL (1D-CNN) algorithm outperforms six ML and three traditional transfer learning algorithms in domain adaptation (DA) tasks.

Figure 7. DA prediction accuracy comparison of ML, DL, and ADDA with manually tuned hyperparameters for rotor crack fault diagnosis.

Test results of MTH-1D-CNN, which is a 1D-CNN with manually tuned hyperparameters, indicate a 67.5% accuracy prediction for domain adaptation tasks of DA 2000-1750 (source training data collected at 2000 RPM, tested on target data collected at 1750 RPM). Test results indicate that MTH-1D-CNN performs better than traditional domain adaptation algorithms (JDA, BDA, EasyTL) in terms of prediction performance; however, it is found that DANN and ADDA outperform the manually tuned 1D CNN (MTH-1D-CNN) in the DA task. Furthermore, ADDA_MTH-1D-CNN, which is ADDA within its architecture with a 1D-CNN and manually tuned hyperparameters, outperforms MTH-1D-CNN and DANN, achieving a maximum prediction accuracy of 75%. The test results show that ADDA increases prediction accuracy by addressing the ‘domain shift’ problem. However, addressing concerns about 1D-CNN performance, such as hyperparameter tuning and overfitting, may improve ADDA’s prediction performance, which is a crucial research need. Additionally, ADDA’s performance compared to JDA, BDA, EasyTL, DeepCORAl, and DANN demonstrates that ADDA’s adversarial GAN-loss-based domain adaptation outperforms statistical distribution, non-parametric domain adaptation, and other domain-invariant feature-based learning methods.

3.2. Study 2: Evaluating the Efficacy of Proposed Methodology for Balanced Data for Multi-Class Balanced Application

Study 1 demonstrates the need for domain adaptation in industrial machinery fault diagnosis systems. The test results of the ADDA in Study 1 indicate a decrease in domain discrepancy. However, the manually tuned hyperparameters of the 1D-CNN exhibit low prediction accuracy; further manual tuning of the CNN hyperparameters requires significant effort, time, and domain expertise. In order to improve the efficiency of the domain adaptation algorithm in Study 2, hyperparameter optimisation based on GA is implemented. The hyperparameters tuned via GA, as shown in Figure 5, are displayed in Table 4. Further, the overfitting issue is addressed by adapting the research outcome of adding a dropout layer at the end of the feature extraction part of the 1D-CNN. The epochs and batch size were optimised with other parameters and obtained as 61 epochs and 12 batch size, respectively. Other parameters are shown in Table 4 below.

Table 4. GA-optimised hyperparameters for GO-1D-CN.

Layer	Type	Filters/Units	Kernel Size	Stride	Pooling Kernel	Activation	Dropout Rate
Input	1D Signal	–	–	–	–	–	–
Conv–Pool 1	Convolution & Pooling	197	41	4	1	ReLU	–
Conv–Pool 2		73	22	2	1	ReLU	–
Conv–Pool 3		151	90	2	2	ReLU	–
Conv–Pool 4		95	75	4	2	ReLU	–
Conv–Pool 5		68	91	5	2	ReLU	0.705
Fully Connected 1	Dense	204	–	–	–	ReLU	–
Fully Connected 2	Dense	321	–	–	–	ReLU	–
Output	SoftMax	6	–	–	–	SoftMax	–

For the GO-1D-CNN training and testing on the same domain, prediction performance reached 99.5% (2000 RPM—source domain). However, once domain adaptation, that is, training on the reference speed (source domain) and testing on another speed (target domain), is carried out, the test results indicate a performance loss of up to 19%, with a prediction accuracy of 80.5%, as shown in Figure 8. Furthermore, the 1D CNN with GA-optimised hyperparameters (GO-1D-CNN) outperforms machine learning models, manually tuned models, and traditional transfer learning algorithms (JDA, BDA, EasyTL) with 80.5% prediction accuracy, utilising prior knowledge.

Figure 8. DA prediction accuracy comparison of ML, DL, and ADDA with GA-optimised hyperparameters for rotor crack fault diagnosis.

ADDA with genetically optimised hyperparameters and GO-1D-CN architecture outperforms GO-1D-CNN and ADDA (MTH_1D-CNN) with manually tuned hyperparameters by 93.22% in prediction accuracy. This shows that hyperparameter tuning is critical for GO-1D-CNN’s feature extraction and classification performance. The results of Study 2 demonstrate that ADDA reduces domain discrepancy, and GO-1D-CNN achieves a performance of 93.22% in feature extraction and domain characteristic classification. In Figure 3a,b, which depict the ADDA framework, domain-invariant features are trained to reduce the loss of domain discrepancy without affecting the classification loss of the source domain. This enables the target domain to align with the source domain, preserving classification capabilities. ADDA with the GO-1D-CNN architecture surpasses ML, statistical, and non-parametric transfer learning algorithms, such as JDA, BDA, and EasyTL. Furthermore, ADDA outperforms other domain-invariant feature learning algorithms, such as DeepCORAL and DANN, in terms of more precise prediction of rotor crack faults across varying machine speeds.

Validation for Adversarial Domain Adaptation

Validation details are provided in this section for Phase 1 at 2000 RPM, Phase 2 DA learning from 2000 to 1500 RPM, and the validation for Phase 3.

• Phase 1—Source Encoder pre-training

The primary objective is to attain a maximum level of classification accuracy in this phase. Optimising hyperparameters using genetic algorithms is crucial for achieving the most accurate predictions with 1D-CNN. Furthermore, CNN’s overfitting concerns are effectively addressed by positioning dropout as the last layer of the CNN architecture. The research outcome of GA optimisation has been implemented in the CNN architecture, and the source encoder has been pre-trained. The pre-trained model undergoes k-fold validation, and the test results are shown in Figure 9. Five-fold cross-validation with 61 epochs ensures that the cross-entropy loss decreases and classification accuracy increases with each epoch.

Figure 9. Validation of the ADDA source encoder pre-training performance for rotor crack fault diagnosis at 2000 RPM.

2.

Phase 2—Adversarial Learning for Target Encoder Training and GAN loss minimisation of the discriminator

An adversarial learning setup involves labelling data as zero (‘0’) for the source domain data and one (‘1’) for the target domain data. The discriminator network then makes an effort to determine the data’s origin domain. A higher loss in the domain is indicative of a properly recognised domain. So, the ADDA algorithm changes the weights of the target encoder to lower the GAN loss, but the source encoder’s weights remain unchanged. Reduced domain discrepancy and optimised target encoder weights are outcomes of a discriminator network that shows a 50% probability of source and target domain confusion, which in turn reduces GAN loss. Figure 10 shows the GAN loss minimisation of the ADDA discriminator after 40 epochs.

Figure 10. Performance of adversarial learning of the discriminator at DA-2000-1750.

3.

Phase 2—Visualisation of Features

The learned features have been visualised using PCA. As shown in the architecture of the CNN (Figure 4), features are extracted using CNN layers and classified through the Softmax layer. Visualising extracted CNN features gains importance in assessing the efficacy and performance of the proposed methodology, both with and without domain adaptation. PCA has been used to visualise learned features in 2-D from high-dimensional data. Figure 11a,b show the extracted features without domain adaptation (GO-1D-CNN) and with domain adaptation (ADDA_GO-1D-CNN). Figure 11a indicates that the 1D-CNN clusters have similar characteristics of rotor crack severity conditions without domain adaptation. Additionally, the clustered features are observed to be distinct in both the source domain and the target domain. Primarily, both the target domain and the source domain are segregated without interference for multiple rotor crack fault severity (multi-class); GO-1D-CNN can efficiently predict if it is trained independently for each speed.

Figure 11. Visualisation of features from final layers of (a) GO-1D-CNN and (b) ADDA_GO-1D-CNN.

Furthermore, it is also observed that certain classes from the source domain overlap with those in the target domain. This situation requires domain adaptation for equipment fault diagnostics. The extracted features from the last layers of the CNN in Figure 11b are used to study the proposed methodology’s domain adaptation capabilities.

No overlap is found between the healthy shaft and varying depths of rotor crack with severity levels 1 and 5 (Table 1). Minor boundary sharing between rotor crack severity levels 1 and 2 of the target domain features, and the source domain clearly explains the reason for the proposed methodology’s highest performance, which reaches only 93.22%. Test findings show that ADDA_GO-1D-CNN predicts better than ML and GO-1D-CNN algorithms, as it minimises data domain differences using past learning.

3.3. Study 3: Performance Analysis of Proposed Methodology for Class Imbalance Data Application

Studies 1 and 2 previously addressed the domain shift problem and the inherent challenges of CNNs, that is, the optimisation of hyperparameters and the overfitting issue. Study 3 furthermore explores the real-world scenario of the fault data availability. The available machinery fault data are multi-class-imbalanced, meaning that healthy data availability is more prevalent, and data availability decreases as fault severity increases. For class-imbalanced data, to overcome the biassed classification nature of machine learning and deep learning models, as shown in Figure 8, the synthetic minority oversampling technique (SMOTE) has been explored within our proposed methodology in Study 3. Study 3 becomes more complex in nature as all performance-related challenges are addressed together, such as CNN’s overfitting and hyperparameter tuning issues, domain shift issues, the complex nature of faults, and data scarcity. As demonstrated in Table 1, the imbalanced data utilised for training the source domain involves decreasing the sample size from a state of good health to various levels of fault severities. Target domain samples, on the other hand, have been reduced from the largest examples with the most severe faults to healthy states. Two different data availability conditions are explored, and the test results are presented in Figure 12 for ‘data class-balanced’ and ‘data class imbalanced’ scenarios.

Figure 12. Prediction Performance on Imbalanced Class Data—Comparison of Different DA Algorithms against the Proposed Methodology for Class Imbalance Data.

Test results of domain-invariant feature learning-based algorithms, such as DeepCORAL and DANN, have been found to perform poorly in cases of data class imbalance. Specifically, DANN could not predict more than 44%; this is due to data scarcity that causes class imbalance during training for both DANN and DeepCORAL. Furthermore, the proposed methodology, i.e., ADDA_GO-1D-CNN, performs well with ‘data class balanced’ datasets, achieving an accuracy of up to 93.22%. When encountering ‘data class imbalance’, it loses up to 54% of its performance in the domain adaptation task, specifically from 2000 RPM to 1750 RPM. The domain adaptation performance at different operating speed conditions indicates a loss in performance due to ‘data class imbalanced.’ The loss of performance of up to 39.2% indicates that even deep learning models, which are believed to perform very well, can fail due to imbalanced class data. This is a real challenge that the industry faces today, and it must be addressed to implement Industry 4.0 through an automatic fault prediction system. The proposed methodology, which addresses various challenges, including overfitting, difficulties with hyperparameter tuning, domain shift, complex rotor crack with varying severity, and data scarcity, achieves a performance improvement of 84.4%. There is an increase in effectiveness of up to 30.4% with the proposed methodology. Additionally, the proposed methodology outperforms all other domain adaptation algorithms, including DeepCORAl and DANN.

Performance Validation of Proposed Methodology on Class Imbalanced Data for DA Task

The test results are verified using the F1-Score metric, specifically designed for use with class-imbalanced data. Table 5 presents the test results for F1-Score, recall, precision, and accuracy across various domain adaptation tasks. This F1-Score, being a harmonic mean, considers both precision and recall in its calculation. Table 5 shows Study 3 test results, indicating that the proposed methodology for ‘class imbalanced data’ achieves the highest F1-Score for the domain adaptation task of 2000 RPM to 1750 RPM (DA 2000-1750) and gained the highest prediction. Thus, the proposed methodology outperforms even with ‘data class imbalance’ in machinery fault diagnosis for variable- speed machine operation conditions.

Table 5. Performance Validation for SMOTE Implemented on Multi-class Imbalanced Data for DA Task.

Domain Adaptation Description	Domain Machine Speed		Domain Adaptation	Precision	Recall	F1-Score	Accuracy
	Source Domain	Target Domain
DA1500–1750	1500	1750	A	0.9243	0.8917	0.9077	87.20
			B	0.4853	0.5772	0.5273	53.50
			C	0.3358	0.3607	0.3478	17.89
			D	0.3681	0.5255	0.4329	36.14
			E	0.7600	0.7451	0.7525	74.00
		2000	A	0.9009	0.8417	0.8703	84.10
			B	0.5907	0.6311	0.6102	54.50
			C	0.4408	0.4463	0.4435	29.12
			D	0.5547	0.4397	0.4906	33.33
			E	0.6779	0.6804	0.6792	67.60
DA1750–1500	1750	1500	A	0.9043	0.8200	0.8601	80.40
			B	0.4983	0.6582	0.5672	46.40
			C	0.5935	0.4022	0.4794	23.51
			D	0.4281	0.5104	0.4656	37.89
			E	0.7711	0.7157	0.7423	71.40
		2000	A	0.9047	0.8083	0.8538	83.30
			B	0.6382	0.6327	0.6355	55.70
			C	0.3369	0.4418	0.3823	23.86
			D	0.3766	0.6000	0.4627	41.05
			E	0.8420	0.7471	0.7917	73.70
DA2000–1500	2000	1500	A	0.7133	0.7283	0.7207	70.80
			B	0.3893	0.4794	0.4297	33.50
			C	0.4499	0.3352	0.3842	21.75
			D	0.5517	0.4034	0.4660	31.58
			E	0.5890	0.5216	0.5532	51.40
		1750	A	0.9623	0.9533	0.9578	93.20
			B	0.5469	0.6479	0.5931	54.00
			C	0.3180	0.4797	0.3825	29.47
			D	0.4598	0.4431	0.4513	44.30
			E	0.8610	0.8510	0.8559	84.40

A => Proposed Methodology for Balanced Data (PM_BAL), B => Class Imbalanced Data on PM_BAL, C => Class Imbalanced Data on_DeepCORAL, D => Class Imbalanced Data on_DANN, E => Proposed Methodology for Class Imbalanced Data (PM_IMB).

4. Conclusions

This study utilises AI to address predictive maintenance issues related to rotor crack fault identification and diagnosis. Performance loss happens due to CNN’s hyperparameter optimisation and overfitting, domain shift, fault complexity, and data class imbalance. The proposed methodology effectively addresses these issues in prediction performance and successfully detects and diagnoses rotor crack faults in industrial machines under various operating conditions. Case Study 1 indicates that ML and DL lose prediction capabilities as operating conditions change. Case Study 2 addresses the hyperparameter tuning and overfitting issues of 1D-CNN. The proposed technique achieves up to 99.5% accuracy under similar conditions. At various operating speeds, the prediction performance is 93.22%. The study indicates that manually tuning the 1D-CNN architecture’s hyperparameters is less accurate than genetic-algorithm-based optimisation. PCA was used to study the characteristics of the last 1D-CNN layer with and without the domain adaptation task.

Domain adaptation reduces domain discrepancy, improving performance. Study 3 examined how ‘class unbalanced data’ affects performance. On an imbalanced dataset, the proposed methodology improves prediction accuracy from 30.4% to 84.4%. Fault predictions for ‘class unbalanced data’ are also evaluated using the F1-Score, the harmonic mean of recall and precision. Benchmarking against various other domain adaptation algorithms validates the work’s efficacy. The methodology demonstrated stable adaptation to varying operating conditions within the tested crack range of 1–5 mm, as it learns changes in vibration response associated with fault progression rather than relying on a specific defect magnitude. Therefore, the proposed approach is not constrained to this range and can be extended to shallower cracks below 1 mm, provided that representative vibration data are available for model training and validation. The present work considers open cracks generated by wire cutting, but the same framework may be extended to different crack types in future studies by acquiring vibration responses that reflect those geometries. Furthermore, the methodology may be extended to crack localisation by employing distributed sensing or multi-position measurements in future investigations. The outcome of the proposed methodology on experimental data demonstrates potential performance improvement, which effectively helps to create an AI-based predictive maintenance programme for diagnosing rotor crack faults of industrial machines under varying operating conditions.