Enhancing Fault Diagnosis in Industrial Processes through Adversarial Task Augmented Sequential Meta-Learning

Abstract

This study introduces the Adversarial Task Augmented Sequential Meta-Learning (ATASML) framework, designed to enhance fault diagnosis in industrial processes. ATASML integrates adversarial learning with sequential task learning to improve the model’s adaptability and robustness, facilitating precise fault identification under varied conditions. Key to ATASML’s approach is its novel use of adversarial examples and data-augmentation techniques, including noise injection and temporal warping, which extend the model’s exposure to diverse operational scenarios and fault manifestations. This enriched training environment significantly boosts the model’s ability to generalize from limited data, a critical advantage in industrial applications where anomaly patterns frequently vary. The framework’s performance was rigorously evaluated on two benchmark datasets: the Tennessee Eastman Process (TEP) and the Skoltech Anomaly Benchmark (SKAB), which are representative of complex industrial systems. The results indicate that ATASML outperforms conventional meta-learning models, particularly in scenarios characterized by few-shot learning requirements. Notably, ATASML demonstrated superior accuracy and F1 scores, validating its effectiveness in enhancing fault-diagnosis capabilities. Furthermore, ATASML’s strategic incorporation of task sequencing and adversarial tasks optimizes the training process, which not only refines learning outcomes but also improves computational efficiency. This study confirms the utility of the ATASML framework in significantly enhancing the accuracy and reliability of fault-diagnosis systems under diverse and challenging conditions prevalent in industrial processes.

1. Introduction

The rapid progression of industrial automation and informatization has significantly elevated the importance of fault-diagnosis technologies in maintaining the reliability and safety of industrial systems [1]. In complex settings such as the chemical, manufacturing and energy sectors, the capacity for precise and timely fault detection is crucial for optimizing production efficiency and averting potential accidents [2,3,4]. Recent advancements in big data and the Internet of Things (IoT) have led to widespread sensor integration across these systems, generating substantial data volumes that enhance the monitoring and diagnostic processes [5,6]. This influx of operational data, while beneficial, often overshadows the sparse fault data, creating a significant imbalance that challenges traditional data-intensive machine learning and deep learning methodologies [7,8]. This disparity underscores the need for robust few-shot learning techniques that can effectively function in environments with limited fault data, marking a critical area of research in industrial intelligence [9,10].

Despite the significant achievements of Few-Shot Learning (FSL) in fields such as natural language processing and image classification [8,11,12,13], its application in the complex domain of fault diagnosis, particularly when handling intricate industrial data, continues to face numerous challenges. Research has shown that existing FSL approaches can be broadly categorized into generative and discriminative model methods, each with its strengths and limitations. For instance, generative models, as described by Lu et al. [11], often enhance model performance in data-scarce environments by generating new samples, whereas discriminative models focus on learning distinguishing features from limited data. Zhang et al. [8] have classified fault-diagnosis methods for small and imbalanced datasets into data augmentation, feature extraction and classifier design. Despite their excellence, these methods commonly exhibit weaknesses such as poor generalization capabilities, sensitivity to adversarial examples and high algorithmic complexity, which can lead to suboptimal performance in industrial applications that demand rapid and accurate diagnostics. Recent studies have shifted focus to addressing FSL fault-diagnosis challenges through meta-learning [14,15,16], with a significant proportion of recent research in time-series signal fault diagnosis concentrating on this approach [17]. However, the practical utility of meta-learning is limited by its high dependency on data quality and distribution, which can adversely affect performance in industrial settings due to data noise and outliers [18]. Meta-learning algorithms like MAML, although quick to adapt to new tasks, require multiple gradient updates, which increases the computational load and can lead to overfitting on sparse data, thus diminishing generalization capabilities [19]. Task sequencing meta-learning introduces a novel method for optimizing the selection and order of learning tasks, but significant differences between tasks can lead to unstable knowledge transfer, affecting the learning outcomes [20].

In recent years, GAN-based data-augmentation algorithms have garnered considerable attention for addressing small-sample problems in fault diagnosis. These algorithms typically follow a sequence of steps: initially collecting data under various fault conditions, then training a GAN model using real signals and finally training classifiers with both real and synthetic signals [21]. This approach enables GAN-based data augmentation to generate a diverse set of samples from limited fault data, thereby enhancing the performance of diagnostic models. For instance, Zhang et al. developed a novel multi-module gradient penalty GAN specifically for generating samples for mechanical fault diagnosis [22]. Furthermore, research by Li et al. utilized a WGAN-GP-based auxiliary classifier to generate high-quality spectra to overcome small-sample challenges [23]. Although methods for generating one-dimensional spectra or two-dimensional images have been extensively explored, Pan et al. proposed a feature generation network that creates one-dimensional feature sets rich in fault information, suitable for further fault identification [24]. Examples of GAN-based data augmentation for different signal types are shown in

Table 1. GAN-based data augmentation according to different signal types [21].

No.	Signal Type	References
1	One-dimensional time domain signals	Liu et al. [25], Zhang et al. [26], Liu et al. [27], Wang et al. [28], Lv et al. [29]
2	One-dimensional frequency domain signals	Li et al. [23], Wang et al. [30], Zheng et al. [31], Wang et al. [32]
3	Two-dimensional images	Huang et al. [33], Shi et al. [34]
4	One-dimensional feature sets	Pan et al. [24], Zhou et al. [35]

below. Building on this foundation, our research has further evolved to incorporate adversarial sample augmentation techniques. This strategy, by introducing targeted adversarial perturbations directly into the data, creates adversarial samples for training. Compared to traditional GAN generation methods, adversarial sample augmentation not only enhances the model’s sensitivity and detection capabilities for complex fault conditions but also improves its robustness against unknown or varying fault patterns. By simulating potential fault variations, our model is better equipped to adapt to the complex and dynamic conditions encountered in actual operations, thereby increasing the accuracy and reliability of fault diagnosis.

Building on our previous discussion regarding the challenges and limitations of meta-learning in industrial fault diagnosis, the research framework provided by Wang et al. [12] offers a systematic approach to thinking about few-shot learning. They have meticulously categorized few-shot learning from three perspectives: data, models and algorithms. Following this framework, our study introduces a comprehensive strategy combining data augmentation, model optimization and algorithmic improvements to overcome the existing limitations of meta-learning techniques, particularly when dealing with complex industrial fault-diagnosis data.

To address the challenges in fault diagnosis, our research integrates adversarial sample generation with serialized task learning to enhance the model’s robustness and adaptability. This method leverages modular design and advanced data-augmentation strategies to enable effective management of diverse fault-diagnosis scenarios. Our approach includes generating adversarial samples to enhance the robustness of the model against varied fault conditions. This strategy not only increases the dataset’s diversity but also sharpens the model’s capability to recognize and respond to anomalies that are not typical of the training data, substantially improving its diagnostic accuracy under operational conditions. The model adopts a modular design that allows for greater structural flexibility, facilitating easy adjustments and optimizations tailored to specific fault-diagnosis tasks. This adaptability enhances the model’s efficiency and accuracy in identifying faults, making it particularly suited to dynamic industrial environments. Employing serialized task learning refines the learning process by structuring the sequence of tasks from simple to complex. This strategic arrangement ensures efficient utilization of limited sample data for training, thereby enhancing the model’s rapid adaptability to new fault types and maintaining performance stability across diverse industrial settings. Together, these elements substantially enhance the model’s fault-diagnosis capabilities, providing a robust framework that significantly improves adaptability and accuracy compared to traditional methods. The integration of adversarial learning within the serialized task framework is particularly effective in preparing the model for the unpredictability of real-world operational conditions.

The Adversarial Task Augmented Sequential Meta-Learning (ATASML) framework introduced in this study enhances diagnostic models by integrating adversarial examples within a meta-learning architecture, significantly improving generalization capabilities. Embedding adversarial tasks during the training phase, ATASML prepares the model to handle unexpected or novel fault scenarios, thus robustly boosting adaptability and accuracy—ideal for industrial settings with variable and complex sensor data.

The principal contributions of this work are encapsulated as follows:

• Development of the ATASML framework that integrates adversarial tasks during training, enhancing the model’s adaptability and robustness. This dynamic integration is crucial for improving diagnostic accuracy and reliability under diverse industrial fault conditions.
• Implementation of a comprehensive data-augmentation strategy in ATASML, incorporating Gaussian noise, temporal warping and adversarial example generation. These techniques broaden training data coverage, significantly improving the model’s anomaly detection and diagnostic capabilities in variable environments.
• Application of a sequential task learning approach where tasks are prioritized based on complexity and informational value. This optimizes the learning process, improving training efficiency and diagnostic precision, and making the process computationally economical.
• Validation of ATASML using industrial-relevant datasets, including the Tennessee Eastman Process (TEP) and Skoltech Anomaly Benchmark (SKAB), shows its superior performance over other well-established models, particularly in few-shot learning scenarios. The outcomes underscore ATASML’s improved accuracy, F1 scores and robust generalization capabilities across a range of complex fault conditions.

The remainder of this paper is organized as follows: Section 2 describes the proposed method in detail. Section 3 presents a case study that applies the method to specific datasets. Section 4 discusses the implications of the experimental results, and Section 5 concludes the paper with a summary of the findings and directions for future research.

2. Proposed Method

This chapter delineates our proposed approach, the Adversarial Task Augmented Sequential Meta-Learning (ATASML) framework, designed to enhance the efficacy of fault diagnosis in complex systems. Initially, we explore the foundational concepts of meta-learning, highlighting its significance in enabling models to generalize from limited data. Subsequently, the discussion transitions to the exploration of task-oriented meta-learning algorithms, acknowledging their efforts to refine the adaptability and computational efficiency of meta-learning models. Building on these insights, we introduce the ATASML framework, focusing on its innovative strategies for data augmentation and the generation of adversarial samples. This structured presentation aims to illustrate the logical progression from meta-learning fundamentals to the sophisticated mechanisms underlying the ATASML framework.

2.1. Fundamentals of Meta-Learning

Meta-learning, or learning to learn, is a significant paradigm in machine learning aimed at enabling models to generalize from limited experiences to perform well on new tasks [18]. This approach leverages accumulated knowledge to quickly adapt to novel learning challenges with minimal data. Meta-learning operates at two levels: the meta-level, focusing on the learning strategy across tasks, and the base-level, where task-specific learning occurs.

The core objective in meta-learning is to fine-tune the model parameters, $\theta$, to optimize performance not just on a single task’s training data but across a diverse set of tasks represented by the distribution $p\left(\mathcal{T}\right)$. This goal is pursued through episodic training, which involves sampling tasks $T\sim p\left(\mathcal{T}\right)$ and dividing each into a support set S for learning and a query set Q for evaluation. The model’s parameters are updated based on the performance on Q, facilitating the model’s ability to assimilate information from S.

Formally, the meta-learning objective for a given task T, with support set S and query set Q, is to minimize the expected loss ${\mathcal{L}}_Q$ on Q after learning from S, as defined by:

$$\underset{\theta }{min}{\mathbb{E}}_{T\sim p\left(\mathcal{T}\right)}\left[{\mathcal{L}}_Q(f_{{\theta }^{\prime };S}\left(x_Q\right),y_Q)\right]$$

(1)

where ${\theta }^{\prime }$ represents parameters updated from learning on S, and $(x_Q,y_Q)$ denote the samples and labels in Q. The ultimate aim is identifying $\theta$ that facilitates rapid adaptation to new tasks from $p\left(\mathcal{T}\right)$.

Various meta-learning models exist, including model-based, optimization-based and metric-based approaches. Each type aims to enhance the model’s ability to learn efficiently from minimal data, thereby broadening the scope of tasks it can handle—from few-shot learning challenges to rapid adaptation in reinforcement learning contexts.

Model-Agnostic Meta-Learning (MAML) [36,37] is a notable strategy that exemplifies meta-learning’s essence by preparing the model to significantly improve performance on new tasks with only a few adjustments. MAML seeks an initial parameter set $\theta$ that is optimal for quick learning across tasks. After initial adaptation through gradient updates on S, resulting in task-specific parameters ${\theta }_T^{\prime }$, the model’s performance is evaluated on Q:    

$${\theta }_T^{\prime }=\theta -\alpha {\nabla }_{\theta }{\mathcal{L}}_T(f_{\theta };S)$$

(2)

This approach’s generality allows its application across various models and tasks, highlighting the versatility and potential of meta-learning.

Despite meta-learning’s and MAML’s advancements, challenges such as high computational demands, assumptions of task homogeneity and sensitivity to hyperparameters remain areas for future research. Addressing these limitations is crucial for advancing meta-learning towards more practical and scalable applications.

2.2. Task-Oriented Meta-Learning Algorithms

Recent developments in task-oriented meta-learning have demonstrated significant advancements in optimizing learning processes through past experiences to enhance performance across a variety of tasks. Notably, task sequencing meta-learning techniques have been introduced to improve adaptability and performance in few-shot learning scenarios by optimizing the order of task presentation.

• Task-Sequencing Meta-Learning (TSML): Introduced by Hu et al. [38], TSML organizes meta-training tasks from simple to complex, enhancing a model’s adaptability in few-shot fault-diagnosis scenarios.
• Task-Specific Pseudo Labelling: Developed by Lee et al. [39], this method employs pseudo labelling to enhance transductive meta-learning by generating synthetic labels for unannotated query sets, significantly improving model performance.
• Task Weighting with Trajectory Optimization: Proposed by Do & Carneiro [40], this approach uses trajectory optimization to automate task weighting, showing improved performance over traditional methods in few-shot learning benchmarks.

Despite these innovative approaches, challenges remain, particularly with the variability between tasks which can lead to unstable knowledge transfer, impacting learning efficacy. This issue is exacerbated in real-world applications where task heterogeneity is prevalent and tasks often deviate significantly from the training distribution. The assumption of task uniformity by these algorithms often does not hold in complex scenarios, leading to a gap between theoretical efficiency and practical applicability. The fixed nature of task prioritization may also fail to accommodate the dynamic variability of real-world data, posing further challenges to model adaptability.

The exploration of these meta-learning algorithms underscores the necessity for a robust framework that intelligently sequences tasks and is resilient to the unpredictable nature of practical applications. The upcoming section introduces the Adversarial Task Augmented Sequential Meta-Learning (ATASML) Framework, which proposes innovative solutions to address these challenges. ATASML integrates data augmentation and adversarial examples within its learning process, significantly enhancing the model’s resilience and generalization capabilities. These features enable ATASML to perform effectively even under the challenging conditions presented by complex fault scenarios, thereby providing a substantial improvement over existing meta-learning frameworks.

2.3. Adversarial Task Augmented Sequential Meta-Learning (ATASML) Framework

The ATASML framework introduces a novel approach to enhance model adaptability and robustness, particularly in fault-diagnosis applications. By integrating data augmentation and adversarial training, ATASML aims to prepare models for a wide array of operational scenarios. This section elaborates on the framework’s methodology, emphasizing data augmentation, adversarial sample generation and the overall algorithmic procedure.

2.3.1. Data Augmentation in the ATASML Framework

Data augmentation is critical in the ATASML framework, ensuring that models are well-equipped for diverse operational scenarios. Techniques such as Gaussian noise addition and temporal warping are employed to enhance data variability and complexity. These techniques are depicted in Figure 1, where the transformation from the original dataset ${\mathcal{X}}_{orig}$ to the augmented datasets ${\mathcal{X}}_{gauss}$ and ${\mathcal{X}}_{warp}$ is illustrated.

The original dataset ${\mathcal{X}}_{orig}$ consists of samples $x_1,x_2,\dots ,x_n$ that capture the true operational dynamics. To enhance the dataset, a window of size W is utilized to segment the continuous time-series data into discrete, overlapping segments. This sliding window technique allows for comprehensive capture of temporal patterns within each segment. Subsequently, the augmentation methods applied to each segment are as follows:

• Noise Addition (NoiseAdd): Gaussian noise $ϵ$ is added to the data within each window, creating a set of noise-augmented samples ${\mathcal{X}}_{gauss}$:

  $${\mathcal{X}}_{gauss}={\mathcal{X}}_{orig}+ϵ,ϵ\sim \mathcal{N}(0,{\sigma }^2)$$

  (3)

  where ${\sigma }^2$ denotes the variance of the noise, modeling the sensor noise and other environmental variations.
• Temporal Warping (TimeWarp): The temporal spacing of data points within each segment is modified, resulting in a set of time-warped samples ${\mathcal{X}}_{warp}$:

  $${\mathcal{X}}_{warp}\left(t\right)={\mathcal{X}}_{orig}(a·t),a\sim U(a_{min},a_{max})$$

  (4)

  where a is a scaling factor that simulates the acceleration or deceleration of process dynamics.

Following augmentation, a selection process ensures that the resulting samples contribute positively to model training. This selection process, including quality assessment and anomaly detection, is critical to maintaining a high-quality augmented dataset ${\mathcal{X}}_{aug}$. The entire augmentation process, including the application of windowing and augmentation techniques, is schematically depicted in Figure 1.

2.3.2. Design of Adversarial Samples

Adversarial samples within the ATASML framework are specifically designed to evaluate and enhance the model’s resilience against operational conditions that mimic real-world disturbances. These samples are derived from both the augmented dataset ${\mathcal{X}}_{aug}$, which comprises samples modified by standard data-augmentation techniques, and the original dataset ${\mathcal{X}}_{orig}$.

The generation of adversarial samples, depicted in Figure 2, involves the following steps:

• Dataset Composition: The dataset for generating adversarial samples, ${\mathcal{X}}_{adv}$, is formulated using:
  • ${\mathcal{X}}_{gauss}$: Samples augmented with Gaussian noise.
  • ${\mathcal{X}}_{warp}$: Samples modified through temporal warping.
  These augmented samples, along with unaltered original samples from ${\mathcal{X}}_{orig}$, are used to construct ${\mathcal{X}}_{adv}$.
• Strategic Sample Selection (S): A subset $S=\left\{x_i^{\prime }\right\}$ from both ${\mathcal{X}}_{aug}$ (comprising ${\mathcal{X}}_{gauss}$ and ${\mathcal{X}}_{warp}$) and ${\mathcal{X}}_{orig}$ is selected to create instances that exhibit potential vulnerabilities under varied operational conditions. This targeted selection process is designed to challenge the model realistically and robustly:
  • Focusing on samples that represent critical transitional states or dynamic conditions.
  • Electing samples that simulate rare operational disruptions or extreme conditions.
  • Choosing instances that might indicate potential system failures or significant performance anomalies.
• Adversarial Optimization Problem: The adversarial samples ${\mathcal{X}}_{adv}$ are generated by solving an optimization problem formulated to maximize the predictive error, thereby testing the model’s robustness:

  $${\mathcal{X}}_{adv}=\left\{x_{ad{v}_i}\mid x_{ad{v}_i}=arg\underset{{\tilde{x}}_i^{\prime }}{max}\mathcal{L}(f\left({\tilde{x}}_i^{\prime }\right),y_i^{\prime }),\mathrm{s}.\mathrm{t}.{\parallel {\tilde{x}}_i^{\prime }-x_i^{\prime }\parallel }_p\le ϵ\right\}$$

  (5)

  where ${\tilde{x}}_i^{\prime }=x_i^{\prime }+\delta$, $\delta =ϵ·\mathrm{sign}\left({\nabla }_{x_i^{\prime }}\mathcal{L}(f\left(x_i^{\prime }\right),y_i^{\prime })\right)$ is the perturbation designed to maximally disrupt the model’s predictions, and $y_i^{\prime }$ represents the labels corresponding to the strategically selected samples, denoting their operational states as normal or anomalous.
• Gradient Sign Method: This method employs the gradient of the loss function with respect to the inputs from S to determine the most effective direction for perturbations, thereby ensuring the adversarial samples are optimally challenging:

  $$\mathrm{sign}\left({\nabla }_{x_i^{\prime }}\mathcal{L}\right)=\mathrm{sign}\left({\nabla }_{x_i^{\prime }}\mathcal{L}(f\left(x_i^{\prime }\right),y_i^{\prime })\right)$$

  (6)

This systematic approach of employing both ${\mathcal{X}}_{aug}$ (including ${\mathcal{X}}_{gauss}$ and ${\mathcal{X}}_{warp}$) and ${\mathcal{X}}_{orig}$ to generate ${\mathcal{X}}_{adv}$ ensures the model is comprehensively evaluated against synthetic distortions as well as baseline conditions. Such rigorous testing is essential for verifying the model’s operational reliability across diverse and potentially disruptive conditions.

2.4. ATASML Algorithmic Procedure

The ATASML framework is designed to enhance fault diagnosis through a systematic approach incorporating meta-learning and adversarial training, which improve model robustness and adaptability.

Refer to Figure 3 for a visual representation of the ATASML algorithm’s architecture, which illustrates the critical components and their interactions within the framework.

• Parameter Initialization: Begin with a random initialization of model parameters ${\theta }_0$, which helps in avoiding local minima and promotes better convergence towards optimal solutions.
• Task Sampling: Sample a set of tasks ${\left\{T_i\right\}}_{i=1}^B$ from the task distribution $p\left(\mathcal{T}\right)$. This step ensures that the model is trained across a diverse set of scenarios, enhancing its generalization capabilities.
• Data Augmentation: Utilize the pre-augmented dataset ${\mathcal{X}}_{aug}$ to select augmented tasks $T_{i,aug}$. This dataset already includes transformations applied via Gaussian noise and temporal warping, thus directly enhancing the data’s variability and complexity:

  $$T_{i,aug}=\mathrm{SelectFrom}({\mathcal{X}}_{aug},T_i)$$

  (7)
• Adversarial Task Generation: Generate adversarial tasks $T_{i,adv}$ using the dataset ${\mathcal{X}}_{adv}$, which has been specifically prepared to challenge the model’s robustness under simulated adversarial conditions:

  $$T_{i,adv}=\mathrm{GenerateAdversarial}({\mathcal{X}}_{adv},T_i)$$

  (8)
• Task Combination and Difficulty Assessment: Combine the original tasks $T_i$ from $p\left(\mathcal{T}\right)$, the augmented tasks $T_{i,aug}$ and the adversarial tasks $T_{i,adv}$ into composite tasks $T_{i,comp}$. This step evaluates the complexity of integrating different types of tasks, which helps in assessing the model’s robustness and adaptability across a diverse range of conditions:

  $$T_{i,comp}=\mathrm{Combine}(T_i,T_{i,aug},T_{i,adv})$$

  (9)
  Assess the difficulty of these composite tasks to ensure the model can handle varying levels of challenge and complexity. This assessment aids in tuning the model’s sensitivity to subtle and extreme variations alike:

  $$D_{T_{i,comp}}=\mathrm{AssessDifficulty}\left(T_{i,comp}\right)$$

  (10)
• Wasserstein Distance Calculation: Compute the Wasserstein distance to measure how closely the composite tasks $T_{i,comp}$ align with the original task distribution, aiding in maintaining the integrity of the model’s training process:

  $$W_{T_{i,comp}}=\mathrm{ComputeWassersteinDistance}(T_{i,comp},p\left(\mathcal{T}\right))$$

  (11)
• Task Ranking: Rank the tasks based on assessed difficulty and Wasserstein distance, which helps in prioritizing the tasks that will most effectively enhance the model’s learning:

  $$\left\{T_j\right\}=\mathrm{RankTasks}(\left\{T_{i,comp}\right\},D_{T_{i,comp}},W_{T_{i,comp}})$$

  (12)
• Support and Query Set Sampling: From each ranked task $T_j$, extract support and query sets $S_j$ and $Q_j$, respectively. These sets are crucial for tuning the model parameters specifically to each task:

  $$S_j,Q_j=\mathrm{SampleSets}\left(T_j\right)$$

  (13)
• Model Optimization: Update the model parameters ${\theta }_i$ using the support set $S_j$ and evaluate the performance on the query set $Q_j$. This step is vital for iterative learning and adaptation of the model:

  $${\theta }_i^{\prime }={\theta }_i-\alpha {\nabla }_{{\theta }_i}{\mathcal{L}}_{S_j}\left(f_{{\theta }_i}\right)$$

  (14)

  $${\mathcal{L}}_{Q_j}\left(f_{{\theta }_i^{\prime }}\right)=\mathrm{EvaluateLoss}(Q_j,f_{{\theta }_i^{\prime }})$$

  (15)
• Global Parameter Update: Perform a global update of the model parameters $\theta$ using the aggregated losses from the query sets across all tasks. This final step ensures the model is refined and ready for deployment:

  $$\theta \leftarrow \theta -\beta {\nabla }_{\theta }\sum _j{\mathcal{L}}_{Q_j}\left(f_{{\theta }_i^{\prime }}\right)$$

  (16)

The systematic methodology employed by the ATASML framework ensures improved diagnostic capabilities across a variety of operational conditions, establishing a robust model well-suited for dynamic environments.

Refer to Algorithm 1 for a complete overview of the procedural steps involved in the ATASML framework. This algorithm highlights the integrated approach to utilizing adversarial and meta-learning techniques to enhance the adaptability and accuracy of fault-diagnosis systems.

Algorithm 1 Adversarial Task Augmented Sequential Meta-Learning (ATASML)

Require:  $p\left(\mathcal{T}\right)$: distribution over tasks. Require:  $\alpha ,\beta$: step size hyperparameters for inner and outer loop optimization.   1: Initialize model parameters ${\theta }_0$ randomly.   2: while not converged do   3:     Sample a batch of tasks ${\left\{T_i\right\}}_{i=1}^B$ from $p\left(\mathcal{T}\right)$.   4:     for each $T_i$ do   5:         Augment $T_i$ to $T_{i,aug}$ using samples from ${\mathcal{X}}_{aug}$.   6:         Generate adversarial tasks $T_{i,adv}$ using samples from ${\mathcal{X}}_{adv}$.   7:         Combine $T_{i,aug}$ and $T_{i,adv}$ into $T_{i,comp}$.   8:         Assess difficulty $D_{T_{i,comp}}$ and compute Wasserstein distance $W_{T_{i,comp}}$ to original task distribution.   9:    end for 10:    Rank all tasks in $\left\{T_{i,comp}\right\}$ based on $D_{T_{i,comp}}$ and $W_{T_{i,comp}}$. 11:    for each ranked task $T_j$ do 12:         Sample support set $S_j$ and query set $Q_j$ from $T_j$. 13:         Optimize ${\theta }_i$ on $S_j$ using gradient descent: $${\theta }_i^{\prime }={\theta }_i-\alpha {\nabla }_{{\theta }_i}{\mathcal{L}}_{S_j}\left(f_{{\theta }_i}\right)$$ 14:         Calculate loss on $Q_j$ with updated parameters: $${\mathcal{L}}_{Q_j}\left(f_{{\theta }_i^{\prime }}\right)=\mathrm{EvaluateLoss}(Q_j,f_{{\theta }_i^{\prime }})$$ 15:     end for 16:     Update global parameters: $$\theta \leftarrow \theta -\beta {\nabla }_{\theta }\sum _j{\mathcal{L}}_{Q_j}\left(f_{{\theta }_i^{\prime }}\right)$$ 17: end while Ensure:  Optimized model parameters $\theta$ for generalized fault diagnosis.

3. Case Study

This section details the empirical evaluation of the Adversarial Task Augmented Sequential Meta-Learning (ATASML) framework, utilizing two benchmark datasets in the field of fault diagnosis: the Tennessee Eastman Process (TEP) and the Skoltech Anomaly Benchmark (SKAB) datasets. Chosen for their comprehensive representation of real-world industrial challenges and diverse fault scenarios, these datasets offer a substantive basis to assess the efficacy of ATASML in diagnosing system faults under varying conditions. The forthcoming experiments aim to elucidate the framework’s ability to leverage limited samples for effective fault diagnosis and its adaptability across distinct operational settings, adhering to the established principles and methodologies in the domain.

3.1. TEP Dataset Analysis

3.1.1. Dataset Overview

The Tennessee-Eastman process (TEP), as described in seminal works by Downs and Vogel [41,42], serves as a fundamental resource for the study of chemical process fault diagnosis. This dataset models a chemical production process and is instrumental in the development and benchmarking of diagnostic algorithms. Illustrated in Figure 4, TEP is structured around five critical subsystems: a reactor, a condenser, a vapor–liquid separator, a recycle compressor and a product stripper. It offers a rich array of data, with each sample comprising 52 features derived from 41 process measurements and 11 manipulated variables, captured at three-minute intervals.

The dataset is segmented into sets representing normal operations and various fault conditions, designed to challenge and evaluate fault-diagnosis methodologies. Specifically, the normal operation dataset encompasses 500 samples, while the fault dataset is detailed into 21 distinct conditions, each represented by 480 samples in the training set. For testing and validation, an additional subset is provided, featuring 960 samples per fault condition, where fault signatures are introduced following an 8 h operational baseline. This structured approach allows for comprehensive training and rigorous testing of diagnostic models like ATASML, underlining the dataset’s significance in advancing fault-diagnosis research.

Given the limited documentation for the final six fault types within the TEP dataset, this study focuses on the analysis and diagnosis of the initial 15 fault categories.

Table 2. TEP Fault Categories Applied in ATASML Fault Diagnosis.

Fault ID	Fault Description	Nature of Disturbance
IDV1	A/C feed ratio, B composition constant	Step change
IDV2	B composition, A/C ratio constant	Step change
IDV3	D feed temperature	Step change
IDV4	Reactor cooling water inlet temperature	Step change
IDV5	Condenser cooling water temperature	Step change
IDV6	A feed loss	Step change
IDV7	C header pressure loss	Step change
IDV8	A, B, C feed composition	Random variation
IDV9	D feed temperature	Random variation
IDV10	C feed temperature	Random variation
IDV11	Reactor cooling water inlet temperature	Random variation
IDV12	Condenser cooling water valve operation	Random variation
IDV13	Reaction kinetics alteration	Slow drift
IDV14	Reactor cooling water valve operation	Sticking
IDV15	Condenser cooling water valve operation	Sticking

provides detailed insights into these fault categories, highlighting their distinctive characteristics. These selected faults encompass a broad range of operational discrepancies, each presenting unique diagnostic challenges.

In particular, Figure 5 illustrates the comparative visualizations of certain process variables under normal operational conditions and during Incident of Disturbance Variable 2 (IDV2) within the training subset. This visual representation aids in understanding the fault’s impact on the process dynamics and the complexity of distinguishing fault conditions based on process data.

Traditional fault-diagnosis techniques often stumble in scenarios where limited or no training data for specific faults is available, underscoring the necessity for innovative approaches capable of learning from sparse datasets. In this context, the application of the Adversarial Task Augmented Sequential Meta-Learning (ATASML) framework represents a significant advancement. ATASML’s methodology, designed to enhance diagnostic accuracy even in data-constrained situations, proves to be especially valuable. By leveraging a meta-learning paradigm and incorporating adversarial task augmentation, ATASML demonstrates enhanced adaptability and efficacy in fault diagnosis across a wide spectrum of fault conditions, as evidenced by its performance on the first 15 faults of the TEP dataset.

Given the Adversarial Task Augmented Sequential Meta-Learning (ATASML) framework’s unique approach to fault diagnosis, the preprocessing of the TEP dataset was tailored to complement its learning strategy. To facilitate this, a sliding window technique was employed, carefully segmenting the dataset to capture the intricate operational dynamics over time. This preprocessing step involved creating windows comprising 40 consecutive data points, corresponding to a 2 h operational window, with a step size of 20 points to ensure continuity and temporal relevance in the captured data.

This data segmentation method is crucial for ATASML’s ability to discern and learn from the nuanced variations and patterns within the process data. It allows the algorithm to effectively utilize each data window, ensuring that the full spectrum of operational dynamics is considered during the learning phase. The structured data thus prepared serves as the foundation for ATASML to apply its meta-learning and adversarial augmentation techniques, aiming to enhance the model’s diagnostic performance.

For the purposes of this study, each of the 15 fault categories within the TEP dataset was dissected into 23 distinct windows, culminating in a total of 345 unique data intervals for in-depth analysis. This segmentation provides a comprehensive dataset for ATASML to train and validate its fault-diagnosis capabilities. Moreover, to concentrate the analysis on the most pertinent data for fault detection, the initial 8 h segment of normal operation data was excluded from the testing subset. This decision ensures a focused evaluation on the segments where fault conditions are present, enabling a more accurate assessment of ATASML’s effectiveness in identifying and diagnosing process anomalies.

3.1.2. Experimental Setup

The ATASML framework leverages a structured experimental protocol to evaluate its performance under varied fault-diagnosis scenarios presented by the TEP dataset. This process is detailed below, from the initial data manipulation to the configuration of the base network designed to process time-series fault data effectively.

Each data sample in ${\mathcal{X}}_{orig}$ undergoes a predefined augmentation process to simulate realistic operational noise and temporal variations. The data is segmented using a sliding window of 30 min, equivalent to 30 data points at 1 min sampling intervals, with a step size of 10 min (10 data points), enhancing the dataset with overlapping window segments for comprehensive coverage. Gaussian noise is added to each data segment to represent typical sensor inaccuracies and environmental fluctuations, using a zero-mean Gaussian distribution with a standard deviation of 5% to 10% of the variable range, which aligns with the common noise levels in process sensors. The samples are temporally warped by modifying the time indices using a uniformly distributed scaling factor from 0.8 to 1.2, which models varying process speeds and operational dynamics.

Adversarial samples are strategically engineered to enhance the model’s resilience by challenging its predictive capabilities. These samples are derived by introducing calculated perturbations into samples from ${\mathcal{X}}_{gauss}$, ${\mathcal{X}}_{warp}$ and ${\mathcal{X}}_{orig}$, specifically designed to maximize prediction errors and test the model’s robustness under adversarial conditions. Samples are perturbed within an $ϵ$-ball centered around the original data points, with $ϵ$ set to 10% of the range of each feature. This perturbation is directed by the gradient of the loss function (calculated via backpropagation), aiming to identify the most sensitive changes that increase the model’s prediction error.

The framework adopts an N-way K-shot methodology for task generation, crucial for evaluating its few-shot learning capabilities. Tasks are composed by randomly selecting N fault types where for each fault type, K examples are chosen to form the support set and another Q examples to construct the query set. This setup facilitates the evaluation of the model across different operational settings and fault conditions. Approximately 10,000 training tasks and 1000 testing tasks are generated to ensure comprehensive model training and robust validation against the diversified conditions depicted in the TEP dataset.

The base network architecture for processing the TEP dataset within the ATASML framework includes layers specifically designed to capture and analyze temporal dependencies and features relevant for time-series fault diagnosis. Initial layers use 1D convolutions with 64 filters of kernel size 3 to extract short-term temporal features, followed by ReLU activation for non-linearity. Batch normalization is applied post-convolution to stabilize and accelerate the learning process, followed by max pooling to reduce feature dimensionality, enhancing model generalizability and computational efficiency. Long Short-Term Memory (LSTM) units (100 units) are employed to capture long-term dependencies across the input features, which is critical for accurately identifying fault patterns over time. The network culminates in a dense layer with softmax activation that classifies the input data into predefined fault categories, based on the learned features and temporal patterns.

The specific parameters for each network module used in the TEP dataset analysis are detailed in

Table 3. Configuration of the Convolutional and LSTM Layers for the TEP Dataset (TimeSeriesConvLSTM_Module_TEP).

Layer (Type)	Configuration	Output Shape
Input	-	(None, T, F)
Conv1D (TimeConv)	64 filters, kernel size 3	(None, T-2, 64)
BatchNorm	-	(None, T-2, 64)
MaxPooling1D	Pool size 2	(None, (T-2)/2, 64)
LSTM	100 units	(None, 100)
Dense (Output)	Softmax activation	(None, num_classes)

and

Table 4. Structure of the Base Learner for the TEP Dataset Using TimeSeriesConvLSTM_Module_TEP.

Module Number	Configuration
1	TimeSeriesConvLSTM_Module_TEP
2	Repeats Module 1
3	Repeats Module 1
4	Repeats Module 1
5	Dense Layer (Output)

, which outline the configurations of convolutional, LSTM and dense layers to optimize fault classification performance.

3.1.3. Comparative Study on Few-Shot Fault Classification

To underscore the efficacy of the ATASML framework, this study compares it with renowned deep learning models such as VGG-11 [43] and ResNet-18 [44], which are benchmarked for their ability to generalize from extensively pretrained features to new, unseen fault conditions. These models are thoroughly adapted to specific fault-diagnosis tasks by fine-tuning on targeted datasets. Our experiments concentrate on demonstrating that the ATASML framework, when subjected to comprehensive network fine-tuning, achieves superior accuracy compared to merely fine-tuning the classifiers, particularly under few-shot learning conditions. Moreover, to ensure a fair comparison across all evaluated methods, an N-way K-shot setup was employed. This setup not only maintains the integrity of the experimental comparisons but also aligns with the research paradigms of few-shot learning, allowing for a precise assessment of the ATASML framework’s performance in complex fault-diagnosis tasks.

As illustrated in Figure 6, a performance comparison between ATASML and conventional deep learning architectures, VGG-11 [43] and ResNet-18 [44], was conducted on the augmented TEP dataset. The results underscore that ATASML significantly outperforms both VGG-11 and ResNet-18 across all few-shot scenarios, particularly excelling in the 3-way 6-shot setting with a diagnostic accuracy of 98.47%. This marked improvement can be attributed to ATASML’s integration of meta-learning and adversarial training strategies, enhancing the model’s generalization capabilities to new, unseen fault conditions. In the more challenging 8-way 5-shot and 8-way 6-shot configurations, although a performance decline is observed for all models, ATASML maintains superior stability and higher diagnostic accuracy. This validates ATASML’s efficacy in managing high-dimensional fault classification tasks, demonstrating robust performance even as the number of categories increases.

3.1.4. Efficacy of Task Sequencing in ATASML

This investigation assesses three meta-learning frameworks: MAML, GOPML and ATASML, each distinct in their approach to task sequencing. MAML serves as a foundational framework that does not prioritize task sequencing. GOPML, conversely, uses gradient information to enhance task selection and ordering, thereby improving specificity and efficiency in learning processes. The nuances and relative advantages of GOPML are detailed further in our prior publications [45].

Empirical evaluations were conducted using the TEP dataset to measure the performance of the algorithms across varied fault classification tasks. The focus was on key metrics such as Accuracy, F1 Score and Precision, which together assess the efficacy of each model in fault classification. These metrics are crucial for evaluating the models’ ability to accurately identify faults and minimize false positives. The results are comprehensively presented in

Table 5. Comparative results of fault classification effectiveness on the TEP dataset.

Methods	3-way 5-shot	3-way 6-shot	8-way 5-shot	8-way 6-shot
MAML Accuracy	72.26 ± 2.3	73.68 ± 2.4	64.60 ± 2.1	65.54 ± 2.1
GOPML Accuracy	85.13 ± 1.4	89.68 ± 1.4	77.29 ± 1.2	79.66 ± 1.3
ATASML Accuracy	95.02 ± 1.0	98.47 ± 1.0	84.57 ± 0.8	90.13 ± 0.9
MAML F1	72.98 ± 2.9	74.16 ± 3.0	64.90 ± 2.6	66.08 ± 2.6
GOPML F1	86.09 ± 1.7	89.23 ± 1.8	75.92 ± 1.5	79.06 ± 1.6
ATASML F1	93.12 ± 1.1	96.50 ± 1.2	82.88 ± 1.0	88.33 ± 1.1
MAML Precision	72.66 ± 3.6	73.54 ± 3.6	62.72 ± 3.1	65.22 ± 3.2
GOPML Precision	84.65 ± 2.5	88.47 ± 2.7	74.66 ± 2.2	78.49 ± 2.4
ATASML Precision	92.17 ± 1.7	95.52 ± 1.7	82.03 ± 1.5	87.43 ± 1.6

.

The data distinctly demonstrate ATASML’s superior performance in utilizing task sequencing to optimize the training process. Notably, ATASML achieves an accuracy of 98.47% in the 3-way 6-shot setting and maintains a high accuracy of 90.13% in the more complex 8-way 6-shot scenario. These findings underscore ATASML’s enhanced efficiency and accuracy in handling complex fault-diagnosis situations compared to MAML and GOPML. For instance, in the 8-way 5-shot configuration, ATASML registers an F1 Score of 82.88%, significantly surpassing GOPML’s 75.92% and MAML’s 64.90%. The precision metrics across all configurations also indicate ATASML’s superior performance, highlighting its effectiveness in minimizing false positives.

3.1.5. Training Process and Performance Stability

To evaluate the training efficiency and performance stability of the ATASML model, we conducted detailed experiments with specific settings. The training process was configured with a total of 20,000 epochs and a batch size of 64, using the Adam optimizer with a learning rate of $5\times {10}^{-4}$. The 3-way 6-shot task was selected to represent a complex fault-diagnosis scenario.

The experiment results demonstrate that the model approaches a stable performance around 15,000 epochs, with diagnostic accuracy peaking at 98.47%. Figure 7 illustrates the training dynamics of the model over the epochs, detailing both the accuracy and loss metrics. The accuracy graph (Figure 7a) reveals a consistent improvement, reaching near-maximal levels, while the loss graph (Figure 7b) showcases a significant reduction in classification loss, stabilizing at a lower rate, which is indicative of the model’s ability to effectively learn and generalize from the training data.

3.1.6. Parameter Sensitivity Analysis for ATASML

This section investigates the sensitivity of the ATASML model to variations in batch size and learning rate, specifically focusing on the most complex 8-way 5-shot scenario. The choice of this scenario aims to rigorously test the model’s performance under demanding conditions, where the complexity of fault classification is significantly higher.

The experiments demonstrate that ATASML achieves its best performance with a batch size of 64, particularly as the model approaches 15,000 epochs, as illustrated in Figure 8a. Increasing the batch size has also shown to place a greater demand on GPU resources, reflecting a balance between computational efficiency and model performance. Additionally, the model’s learning rate was methodically adjusted across the range from $1\times {10}^{-5}$ to $1\times {10}^{-3}$, with ten iterations conducted at each learning rate to ensure statistical reliability and robustness of the findings. The results, displayed in Figure 8b, indicate that the accuracy stabilizes and peaks at a learning rate of $5\times {10}^{-4}$, achieving an optimal diagnostic accuracy of 84.57%.

Notably, when the learning rate was increased to $1\times {10}^{-3}$, a subsequent decrease in diagnostic accuracy was observed. This reduction can typically be attributed to the optimizer overshooting the minima during the training process. At higher learning rates, the gradient descent steps become too large, potentially bypassing the optimal solution and leading to less stable training convergence.

The data from this analysis is crucial for fine-tuning the ATASML model’s parameters to ensure maximal efficiency and accuracy in real-world applications. It also offers a framework for future research to explore the impact of other parameter variations on the performance of meta-learning models in fault diagnosis.

3.2. SKAB Dataset

3.2.1. Datasets Description

The Skoltech Anomaly Benchmark (SKAB) [46] serves as a pivotal resource for anomaly detection within simulated industrial environments, reflecting real-world operational challenges. This dataset encompasses a range of subsystems monitored by various sensors, capturing data on parameters such as temperature, pressure and flow rates. SKAB consists of 34 time-series datasets, each representing a different operational scenario within an industrial process. One dataset is designated as anomaly-free to establish a baseline for normal operations, while the remaining 33 datasets exhibit transitions from normal to anomalous states, simulating faults within a pumping system due to induced anomalies (Figure 9). Anomalies are integrated into the datasets to mimic faults from diverse sources, including valves and pumps. These faults specifically affect the fluid dynamics, manifesting as subtle yet detectable anomalies aimed at testing the limits of diagnostic algorithms. The anomalies are present in both training and testing subsets, ensuring comprehensive exposure to varied conditions. The SKAB dataset provides a comprehensive set of fault scenarios, as visualized in Figure 10. These scenarios simulate fluid leaks and additions, highlighting the complexity and variability of anomaly patterns within the dataset, which challenge the detection algorithms.

The ATASML algorithm requires a methodically preprocessed dataset to perform efficiently. For the SKAB dataset, preprocessing involved the application of a sliding window technique, segmenting the dataset into windows of 30 consecutive data points each. This window size was strategically chosen to capture significant operational dynamics, with a step size of 15 points to maintain overlap and continuity. Each window represents an individual learning task, forming a structured dataset $D=\left\{(x^{\left(j\right)},y^{\left(j\right)})\right\}$, where $x^{\left(j\right)}$ denotes the input features and $y^{\left(j\right)}$ the corresponding labels, which classify the operational state as normal or anomalous. This task-specific dataset formulation is critical for training the ATASML algorithm, which enhances its capability to recognize and adapt to new and complex anomaly patterns effectively.

ATASML’s application capitalizes on advanced meta-learning strategies that utilize both inherent data features and artificially induced anomalies to train robust anomaly detection models. By incorporating adversarial samples during the training phase, ATASML enhances the model’s adaptability and sensitivity to subtle operational changes, which are often indicative of potential faults. The algorithm’s structured learning approach, enriched with sequential and adversarial training components, provides significant advantages over conventional models. Specifically, by training on a blend of normal and adversarially augmented data, ATASML fosters a refined understanding of typical and atypical patterns, thereby enhancing the accuracy of anomaly detection.

The core of ATASML’s algorithm is its meta-learning component, designed for rapid adaptation to new tasks. This capability enables the algorithm to effectively adjust to previously unseen anomalies, substantially reducing the occurrence of false negatives. Furthermore, the strategic implementation of adversarial tasks not only sharpens the algorithm’s diagnostic precision but also expedites the learning process. These attributes render ATASML exceptionally suitable for real-time anomaly detection scenarios in industrial settings, where the dynamics of operational conditions are constantly changing and the costs associated with diagnostic errors are critically high.

3.2.2. Experimental Setup

The experimental setup for the ATASML framework on the SKAB dataset adheres to a structured protocol designed to rigorously assess its performance under varied industrial fault scenarios. This setup is crafted to highlight the framework’s robustness and adaptability through comprehensive experimental procedures involving both traditional and adversarial learning techniques.

Data preprocessing for the SKAB dataset involves a sliding window technique, where data is segmented into windows of 30 consecutive data points each. This segmentation captures essential temporal dynamics and a step size of 15 points ensures adequate overlap and continuity between samples. Such preprocessing is crucial to ensure the data’s suitability for complex anomaly detection tasks facilitated by the ATASML framework.

This experimental setup on the SKAB dataset emphasizes a comprehensive assessment of the ATASML framework’s performance under diverse industrial fault scenarios. Rather than focusing on few-shot fault classification, which is less representative of the SKAB dataset’s unique characteristics and anomaly patterns, the approach here leverages a broader learning context. This involves employing extensive training datasets to thoroughly evaluate the framework’s capabilities. Such an experimental design aims to robustly validate the generalization, accuracy and diagnostic precision of ATASML, particularly by showcasing detailed performance metrics throughout the training process, including accuracy improvements and loss reductions.

In line with few-shot learning methodologies, the N-way K-shot approach is employed for constructing learning tasks. Here, ‘N’ distinct fault types are randomly selected from the dataset, and ‘K’ examples from each type are used to form the support set. Additional samples are used to construct the query set, culminating in approximately 10,000 training tasks and 1000 testing tasks. This sampling strategy ensures a comprehensive evaluation over a wide array of fault scenarios, thus providing a robust measure of the model’s diagnostic capabilities.

Adversarial training is integral to the ATASML approach, enhancing the model’s ability to generalize from limited data and to recognize subtle anomalies indicative of faults. Strategic perturbations are introduced to the training data, forming adversarial samples that challenge the model’s predictive accuracy. These perturbations are bounded by an $ϵ$-ball centered around the original data points, with $ϵ$ set to 10% of the range of each feature, aimed at maximizing the prediction error and thereby simulating realistic fault conditions more effectively.

The network architecture tailored for the SKAB dataset is designed to effectively harness both the feature-specific and temporal dynamics essential for accurate fault diagnosis. The architecture incorporates convolutional layers for initial feature extraction followed by LSTM units to capture long-term dependencies.

The learning rates for the task-level (inner loop) updates are set at $\alpha =0.01$, and for the meta-level (outer loop) updates at $\beta =0.001$. The training involves preliminary adaptation through five inner update steps, followed by ten fine-tuning steps to refine the model parameters based on the insights gained from the adversarial samples, optimizing the model for high precision and reliability in fault detection.

The configuration detailed in

Table 6. Configuration of the Convolutional and LSTM Layers for the SKAB Dataset (TimeSeriesConvLSTM_Module_SKAB).

Layer (Type)	Configuration	Output Shape
Input	-	(None, T, F)
Conv1D (TimeConv)	32 filters, kernel size 5	(None, T-4, 32)
BatchNorm	-	(None, T-4, 32)
MaxPooling1D	Pool size 2	(None, (T-4)/2, 32)
LSTM	50 units	(None, 50)
Dense (Output)	Softmax activation	(None, num_classes)

and

Table 7. Structure of the Base Learner for the SKAB Dataset Using TimeSeriesConvLSTM_Module_SKAB.

Module Number	Configuration
1	TimeSeriesConvLSTM_Module_SKAB
2	Repeats Module 1
3	Repeats Module 1
4	Repeats Module 1
5	Dense Layer (Output)

outlines the modular structure and specific parameters of the network, demonstrating the sequential application of convolutional and LSTM layers tailored to the unique requirements of the SKAB dataset. This design efficiently processes complex time-series data, effectively balancing feature extraction and temporal dependency modeling, which is critical for the continuous monitoring and anomaly detection tasks prevalent in industrial settings.

3.2.3. Efficacy of Task Sequencing in ATASML

This study evaluates the efficacy of task sequencing within the ATASML framework using the SKAB dataset. Unlike traditional setups, ATASML integrates advanced data augmentation and adversarial training directly into its learning process. This approach is designed to enhance the model’s adaptability and robustness by utilizing sophisticated simulations of faults within the original dataset, thereby providing a rigorous testing ground for assessing the framework’s generalization capabilities against other models such as MAML and GOPML.

The classification performance of ATASML, MAML and GOPML on the SKAB dataset is summarized in

Table 8. Fault classification results with fluctuation on the SKAB dataset.

Methods	3-way 5-shot	3-way 6-shot	8-way 5-shot	8-way 6-shot
MAML Accuracy	71.44 ± 2.3	72.33 ± 2.3	63.16 ± 2.0	64.06 ± 2.0
GOPML Accuracy	84.18 ± 1.3	84.67 ± 1.4	74.32 ± 1.2	74.80 ± 1.2
ATASML Accuracy	94.25 ± 0.9	94.79 ± 0.9	84.01 ± 0.8	84.55 ± 0.8
MAML F1	68.50 ± 2.7	69.48 ± 2.8	61.60 ± 2.5	62.58 ± 2.5
GOPML F1	80.03 ± 1.6	80.74 ± 1.6	71.71 ± 1.4	72.43 ± 1.4
ATASML F1	92.37 ± 1.1	92.89 ± 1.1	82.33 ± 1.0	82.86 ± 1.0
MAML Precision	73.09 ± 3.6	73.17 ± 3.6	64.71 ± 3.2	64.78 ± 3.2
GOPML Precision	86.02 ± 2.6	85.62 ± 2.6	75.51 ± 2.3	75.11 ± 2.3
ATASML Precision	91.42 ± 1.6	91.95 ± 1.7	81.49 ± 1.5	82.01 ± 1.5

. These results highlight the models’ capabilities across various levels of task complexity, from 3-way 5-shot to 8-way 6-shot settings, emphasizing the benefits of ATASML’s methodological innovations.

ATASML outperforms both MAML and GOPML significantly, demonstrating its superior adaptability and efficiency in learning from limited samples. For instance, ATASML achieves an accuracy of 94.25% in the 3-way 5-shot setting, considerably higher than GOPML’s 84.18% and MAML’s 71.44%. This superior performance is attributed to ATASML’s use of task sequencing and its ability to leverage data augmentation and adversarial samples effectively.

3.2.4. Advanced Training Dynamics and Stability Analysis

To further substantiate the efficacy of the ATASML framework, a detailed analysis of the training process on the SKAB dataset is presented, specifically focusing on the 3-way 6-shot configuration. This configuration was chosen due to its balanced challenge in fault classification, providing insights into the model’s performance under moderately complex scenarios.

The experiments were configured with a batch size of 64 and an extended training duration of up to 20,000 epochs to ensure robust model convergence. The Adam optimizer was employed with a learning rate of $5\times {10}^{-4}$, slightly higher than typical settings to accommodate the complex nature of the SKAB dataset. This setup aims to rigorously test the adaptability and learning efficiency of the ATASML framework under varied fault conditions.

Two key performance metrics were tracked throughout the training process: Diagnostic Accuracy (%) and Classification Loss (expressed in $e-2$ scale). The training dynamics are illustrated in two parallel graphs, aligning with the methodology applied for the TEP dataset, enabling a direct comparison between the datasets.

• Diagnostic Accuracy (%): As depicted in Figure 11, the accuracy improves steadily with epochs and approaches a stability phase between 17,000 to 18,000 epochs, eventually reaching an optimal accuracy of 94.79%. This gradual stabilization, later than observed in the TEP dataset experiments, reflects the SKAB dataset’s increased complexity and diversity in fault scenarios.
• Classification Loss: The loss reduction trajectory, shown in Figure 11, indicates that the model efficiently learns to minimize error over extended epochs, substantiating the algorithm’s capability to handle complex anomaly detection tasks effectively.

These findings are pivotal when juxtaposed with the TEP dataset outcomes, where the model achieved stability quicker. The extended stabilization period in the SKAB dataset underscores the intricate fault patterns and the diverse operational conditions simulated within this dataset. Such comparisons not only demonstrate ATASML’s robust performance but also its versatility and scalability across different industrial datasets.

These results validate the efficacy of incorporating task sequencing and adversarial examples in the training process, as ATASML not only improves on basic accuracy metrics but also enhances precision and F1 scores significantly. This performance uplift is crucial in scenarios where even minor faults need to be detected reliably to prevent potential operational failures.

4. Discussion

The Adversarial Task Augmented Sequential Meta-Learning (ATASML) framework has been rigorously tested across complex industrial datasets, such as the Tennessee Eastman Process (TEP) and Skoltech Anomaly Benchmark (SKAB), demonstrating substantial improvements in fault-diagnosis capabilities. ATASML is particularly effective in few-shot learning scenarios that often challenge traditional models due to limited data availability.

A key innovation of ATASML is its use of adversarial examples integrated within a meta-learning structure, which significantly enhances the model’s ability to generalize from limited samples. Unlike traditional approaches such as MAML and GOPML, which, while robust, do not specialize in rapid adaptation to new and complex tasks, ATASML’s strategic task sequencing further refines this capability by arranging learning tasks to optimize both the accuracy and speed of the learning process, utilizing adversarially augmented data to effectively challenge the model under diverse conditions.

To underscore the efficacy of the ATASML framework, this study compares it with renowned deep learning models such as VGG-11 and ResNet-18, which are benchmarked for their ability to generalize from extensively pretrained features to new, unseen fault conditions. These models are thoroughly adapted to specific fault-diagnosis tasks by fine-tuning on targeted datasets. Our experiments concentrate on demonstrating that the ATASML framework, when subjected to comprehensive network fine-tuning, achieves superior accuracy compared to merely fine-tuning the classifiers, particularly under few-shot learning conditions. Moreover, to ensure a fair comparison across all evaluated methods, an N-way K-shot setup was employed. This setup not only maintains the integrity of the experimental comparisons but also aligns with the research paradigms of few-shot learning, allowing for a precise assessment of the ATASML framework’s performance in complex fault-diagnosis tasks.

However, the framework’s computational intensity, particularly when processing large, complex datasets, highlights an area for potential improvement. Future work will focus on optimizing the computational efficiency of ATASML to enhance its scalability and practical applicability in industrial settings. This will involve refining the adversarial training components and exploring more efficient ways to implement task sequencing that reduces computational demands while maintaining high diagnostic accuracy.

5. Conclusions

The deployment of the Adversarial Task Augmented Sequential Meta-Learning (ATASML) framework marks a significant advancement in the field of intelligent fault-diagnosis systems. Through comprehensive testing across the Tennessee Eastman Process (TEP) and Skoltech Anomaly Benchmark (SKAB) datasets, ATASML has demonstrated notable improvements in diagnostic accuracy and model robustness, particularly under few-shot learning conditions.

• Superior Generalization: ATASML achieves a diagnostic accuracy up to 98.47% in 3-way 6-shot scenarios on the TEP dataset and maintains strong performance in more complex 8-way settings with an accuracy of up to 90.13%. These results are significantly higher than those achieved by traditional models such as MAML and GOPML, illustrating ATASML’s robust adaptability to varied fault conditions.
• Enhanced Diagnostic Precision: In SKAB dataset evaluations, ATASML consistently outperformed comparisons, achieving as high as 94.79% accuracy in 3-way 6-shot settings. This precision underlines the framework’s capability to effectively handle even the subtlest anomalies in industrial environments.
• Efficient Learning Process: The strategic integration of adversarial learning and task sequencing in ATASML not only accelerates the learning process but also enhances the precision and reliability of fault diagnostics across diverse operational scenarios.

Conclusively, ATASML sets a new benchmark in fault diagnosis by effectively learning from limited data and adapting swiftly to new, intricate operational scenarios. These capabilities are critical in reducing operational downtime and maintenance costs, thereby enhancing safety by mitigating risks associated with delayed or missed fault detections.

Moving forward, the focus will be on further enhancing the computational efficiency of the ATASML framework to facilitate its scalability and broader industrial application. Additional research will explore the integration of more advanced adversarial techniques and the expansion of the framework to accommodate a broader spectrum of industrial conditions, potentially including real-time learning scenarios and the development of more generalized models that can perform across various industries with minimal adjustments.