CLAIRE: Compressed Latent Autoencoder for Industrial Representation and Evaluation -- A Deep Learning Framework for Smart Manufacturing

@key newfloatplacement @keynewfloatname @keynewfloatfileext @keynewfloatwithin CLAIRE: Compressed Latent Autoencoder for Industrial Representation and Evaluation — A Deep Learning Framework for Smart Manufacturing Mohammadhossein Ghahramani, and Mengchu Zhou M. Ghahramani is with Birmingham City University, UK, (e-mail: mohammadhossein.ghahramani@bcu.ac.uk)M. C. Zhou is with the Helen and John C. Hartmann Department of Electrical and Computer Engineering, New Jersey Institute of Technology, Newark, NJ 07102, USA (e-mail: zhou@njit.edu). Abstract Accurate fault detection in high-dimensional industrial environments remains a major challenge due to the inherent complexity, noise, and redundancy in sensor data. This paper introduces CLAIRE, i.e., a hybrid end-to-end learning framework that integrates unsupervised deep representation learning with supervised classification for intelligent quality control in smart manufacturing systems. It employs an optimized deep autoencoder to transform raw input into a compact latent space, effectively capturing the intrinsic data structure while suppressing irrelevant or noisy features. The learned representations are then fed into a downstream classifier to perform binary fault prediction. Experimental results on a high-dimensional dataset demonstrate that CLAIRE significantly outperforms conventional classifiers trained directly on raw features. Moreover, the framework incorporates a post hoc phase, using a game-theory-based interpretability technique, to analyze the latent space and identify the most informative input features contributing to fault predictions. The proposed framework highlights the potential of integrating explainable AI with feature-aware regularization for robust fault detection. The modular and interpretable nature of the proposed framework makes it highly adaptable, offering promising applications in other domains characterized by complex, high-dimensional data, such as healthcare, finance, and environmental monitoring. 00footnotetext: Index Terms: Explainable AI, Autoencoder, Fault Detection, Deep Learning, High-Dimensional Data, Feature Extraction. I Introduction Maintaining product integrity and promptly identifying faults are essential objectives in contemporary industrial systems. The integration of IoT-based sensors and advanced monitoring infrastructure has resulted in the rapid accumulation of high-dimensional process data. Although these data streams hold promise for detecting anomalies, their high noise levels and redundant features reduce the efficacy of conventional machine learning models when applied to unprocessed inputs. As manufacturing operations grow in complexity, there is an increasing demand for robust and adaptive data-driven methods to support quality assurance. Traditional supervised learning models often underperform in these settings due to their limitations in managing the dimensionality and interdependencies present in sensor data. Recent progress in computational power, along with the emergence of innovative learning paradigms, has brought substantial improvements to many industrial applications. These advancements have paved the way for more effective strategies to address complex problems. Among the most influential developments is the rise of deep learning, which has reshaped the way high-dimensional data is handled. Deep neural networks have proven highly effective in domains such as image analysis, speech recognition, and industrial system monitoring. These methods have also gained prominence in feature extraction due to their ability to automatically learn patterns from raw data. Convolutional Neural Networks (CNNs) and Recurrent Neural Networks (RNNs) are widely used in image and sequence modeling, respectively [1, 2, 3]. CNNs excel at capturing spatial patterns in structured data like images, while RNNs are effective for sequential inputs and temporal dependencies. However, their reliance on spatial or temporal structure limits their applicability in smart manufacturing, where sensor data is often high-dimensional and unstructured. In such settings, autoencoders provide a more suitable alternative. Designed for unsupervised learning and dimensionality reduction, they can effectively filter noise and redundancy, uncovering latent features that capture the essential structure of complex industrial data. This property of autoencoders makes them particularly useful for fault detection in smart manufacturing. By learning compact and informative representations, they can enable us to identify subtle patterns linked to equipment faults or product defects. This study addresses the challenge of accurate product quality prediction in smart manufacturing environments characterized by high-dimensionality and redundant features. When traditional classifiers are applied directly to such raw inputs, their performance is often compromised due to the curse of dimensionality and the presence of non-informative features. To overcome these limitations, we propose CLAIRE (i.e., Compressed Latent Autoencoder for Industrial Representation and Evaluation), as a hybrid end-to-end framework that integrates unsupervised deep representation learning with supervised classification. Specifically, an optimized deep autoencoder is implemented to learn compact and informative latent representations that capture the intrinsic structure of the input data while filtering out redundancy. These learned features are subsequently used as inputs to a downstream classifier for binary fault prediction. By decoupling the feature extraction and classification phases, the proposed approach enhances generalization performance and improves predictive robustness in complex industrial settings. To interpret the latent space including learned features, we employ an advanced interpretability technique, i.e., a game theory-based approach, to gain insights into which features are most influential in the model’s decision-making process. The name ”CLAIRE” reflects our proposed framework’s core philosophy of clarity and transparency in AI. Notably, while deep learning models are often perceived as black boxes, CLAIRE is designed with transparency in mind–offering not just predictive performance, but also a clearer understanding of the learned representations. This work intends to make the following new contributions: 1. It proposes CLAIRE, an end-to-end hybrid framework that couples unsupervised deep representation learning with supervised fault classification. Unlike existing approaches that treat feature extraction and classification as disjoint steps, CLAIRE integrates an optimized denoising autoencoder with a kernel-based SVM, yielding compact latent embeddings that are directly optimized for discriminative fault detection in high-dimensional manufacturing data; 2. It introduces a novel joint optimization strategy that adaptively tunes both reconstruction and classification objectives through dynamic learning rate scheduling. This includes the use of latent variance regularization, which promotes well-separated and informative embeddings; and 3. It develops an explainability phase that applies game-theoretic analysis to latent space. Beyond simple feature attribution, this phase reveals i) how the learned embeddings achieve clear class separation, and i) which raw input features most strongly drive this separation. This provides actionable and domain-relevant insights that improve model transparency and increase trust in its deployment for fault diagnosis in industrial systems. The remainder of this paper is structured as follows. Section I reviews existing literature on fault detection and deep learning techniques. The proposed hybrid model and its architectural components are detailed in Section I. Experimental setup, evaluation metrics, and performance results are presented in Section IV. Finally, Section V concludes the paper and outlines potential directions for future research. I Related Work Traditional Statistical Process Control (SPC) methods, while effective for low-dimensional monitoring, often fall short in handling the complexity and scale of modern sensor-based manufacturing data. Because of this, recent years have witnessed a growing interest in leveraging Machine Learning (ML) and Artificial Intelligence (AI) techniques for industrial fault detection and quality control. However, the sheer volume and dimensionality of sensor data in these settings introduce new challenges, such as redundancy, noise, and overfitting. To address these issues, feature selection has become essential for enhancing the performance and interpretability of fault detection models. By selecting the most relevant features from high-dimensional sensor data, models become more robust to noise and computationally efficient. This section categorizes feature selection methods into traditional and advanced approaches, highlighting their evolution and limitations. I-A Traditional Approaches Conventional feature selection techniques are broadly categorized into filter, wrapper, and embedded methods [4, 5]. Filter methods, such as Mutual Information Maximization (MIM), Minimum Redundancy Maximum Relevance (MRMR), and Fast Correlation-Based Filter (FCBF), assess features based on statistical metrics like correlation or mutual information [6]. These methods are computationally efficient and model-agnostic but typically evaluate each feature independently, overlooking interactions and non-linear relationships among features [7]. Wrapper methods, such as Recursive Feature Elimination (RFE), involve iterative training of a predictive model to assess subsets of features based on classification performance. While they often yield higher prediction accuracy, they are computationally intensive, especially in high-dimensional low-sample-size (HDLSS) settings, and are prone to overfitting. Embedded methods, including LASSO regression and decision tree-based models, incorporate feature selection during model training by introducing regularization or through hierarchical feature evaluation. Although more scalable than wrapper approaches, embedded methods may still fall short when modeling complex, non-linear dependencies and often depend on strong assumptions about the underlying data structure [8]. Collectively, these traditional approaches struggle with scalability, interaction modeling, robustness to noise, and generalizability in modern industrial applications involving high-dimensional, noisy, and heterogeneous sensor data [9, 10]. InputEncoderLatent zDecoderReconstructed InputReconstruction LossLatent Variance Loss Figure 1: Encoder–Decoder Structure with Latent Space Regularization. This architecture incorporates reconstruction loss and latent variance loss. Note that, a supervised learning layer, optimized using cross-entropy loss and entropy regularization, and a latent exploration module (both not shown here) follow the encoder. These components are discussed in detail throughout the paper and illustrated in Fig. 2. I-B Advanced Approaches To address the limitations of traditional feature selection techniques, recent studies have increasingly explored metaheuristic optimization and deep learning-based approaches for industrial data modeling. Metaheuristic methods, such as Evolutionary Algorithms (EAs), leverage population-based global search strategies to identify informative feature subsets in high-dimensional spaces [11, 12, 13, 14]. To alleviate their high computational cost, surrogate-assisted variants have been introduced, where fitness evaluations are approximated using probabilistic models such as Gaussian processes [15, 16]. Reinforcement Learning (RL) has also been investigated as an adaptive alternative, framing feature selection as a sequential decision-making process. For example, Fan et al. [17] propose an interactive RL-based feature selection strategy guided by classifier feedback, although scalability and training complexity remain key challenges in industrial settings. Alongside these optimization-based paradigms, deep learning has emerged as a powerful tool for automated feature extraction and representation learning. Deep neural networks have demonstrated remarkable success in learning hierarchical and non-linear feature representations across a wide range of domains, including image analysis, speech recognition, and industrial system monitoring. In manufacturing and process industries, deep learning models are particularly attractive due to their ability to operate directly on raw or minimally processed sensor data and to capture complex dependencies among process variables. Among deep learning techniques, autoencoder-based models have gained significant attention for unsupervised representation learning in industrial environments. Autoencoders map high-dimensional inputs into compact latent representations while preserving essential information, making them well suited for noisy, redundant, and highly correlated sensor data commonly encountered in smart manufacturing systems [18, 19]. Variants such as denoising autoencoders (DAEs) further enhance robustness by explicitly learning to reconstruct clean signals from corrupted inputs [20]. More advanced architectures have been proposed to capture temporal or structural dependencies, including self-attentive convolutional autoencoders for wind turbine monitoring [21], position-encoding denoising autoencoders for missing-data imputation, and deep residual networks for data-driven quality prediction in industrial processes [22]. Autoencoder-based frameworks have also been successfully applied to other industrial and infrastructure-oriented tasks. For instance, Meng et al. [23] propose a hierarchical variational autoencoder (VAE) for physical-layer authentication in Industrial Internet of Things (IIoT) environments, demonstrating how hybrid AE–VAE architectures can learn robust representations under limited and uncertain training data. Similarly, Shahid et al. [24] investigate VAEs and recurrent autoencoder models for anomaly detection and knowledge transfer in electricity and district heating consumption, highlighting the effectiveness of reconstruction-based learning for generalizable industrial anomaly detection. These studies collectively illustrate the versatility of autoencoder-based frameworks in handling diverse industrial data challenges. Beyond reconstruction-focused learning, recent research has also explored probabilistic and information-theoretic extensions of autoencoders, such as information bottleneck formulations [25] and representation disentanglement techniques [26, 27]. While these approaches are effective for generative modeling or factorized representation learning, their objectives are not explicitly aligned with discriminative fault detection or latent-space compactness under industrial noise conditions. In parallel, self-supervised and contrastive learning frameworks [28, 29] have been proposed to learn general-purpose representations through instance-level discrimination; however, such methods typically rely on carefully designed data augmentations or structural assumptions that are not naturally available in tabular industrial sensor datasets. In this work, we build upon the strengths of encoder–decoder-based representation learning while explicitly addressing the requirements of industrial fault detection. We propose an optimized denoising autoencoder architecture that integrates reconstruction loss with a latent variance regularization term, aiming to shape the geometry of latent space toward compact and stable embeddings. This unsupervised representation learning phase forms the foundation of the framework and is complemented by a downstream kernel-based classifier and a latent exploration layer for interpretability. By combining discriminative latent regularization with a game-theoretic explanation mechanism, the proposed framework seeks to balance predictive performance, robustness, and transparency. To clarify the relationship between CLAIRE and some representative deep representation learning paradigms, a conceptual comparison is summarized in Table I. TABLE I: Conceptual comparison of representative deep representation learning frameworks for industrial fault detection. Method Category Objective and Key Characteristics Standard Autoencoder (AE) Learn compact representations by minimizing reconstruction error; denoising AEs improve robustness but latent space geometry is not explicitly constrained for discriminative separability or compactness. Variational AE Introduce probabilistic latent variables with KL-based regularization to enforce prior matching and promote disentanglement; primarily designed for generative modeling rather than fault-specific discrimination. Information Bottleneck AE Optimize a trade-off between reconstruction and information compression; focus on minimal sufficient representations rather than explicit latent compactness or class separation. Self-supervised and Contrastive Learning Learn representations via instance-level contrastive objectives and data augmentations; often require structured inputs or domain-specific augmentation strategies, limiting applicability to tabular industrial sensor data. CLAIRE (Proposed) Jointly optimizes denoising reconstruction and latent variance regularization to explicitly shape compact and stable latent embeddings for fault discrimination, complemented by kernel-based classification and latent-level interpretability. I Problem Formulation and Proposed Approach I-A Dataset and Problem Overview This work utilizes two publicly available benchmark datasets commonly used in the domain of manufacturing process monitoring, i.e., SECOM and Tennessee Eastman Process (TEP). SECOM contains operational data collected during a real semiconductor manufacturing process with a target variable indicating the production outcome, i.e., success or failure. It includes more than 500 features corresponding to various sensor readings. The target variable is binary, indicating whether the manufacturing process results in success (1) or failure (0). Some features contain null values, making imputation impractical; thus, these features are excluded from the dataset. TEP is a widely used simulated chemical process dataset that represents a realistic industrial process with multiple operating modes and both normal and faulty conditions [30]. It contains 52 process variables recorded as multivariate data, along with labeled fault classes, which makes it suitable for evaluating fault detection and diagnosis methods. Both datasets exhibit substantial class imbalance, which is a well-documented challenge in industrial fault detection. In SECOM, the proportion of defective samples is smaller than that of successful production runs, and in TEP, certain fault classes occur less frequently than normal operating conditions. To mitigate the bias induced by this imbalance, we employ stratified sampling, ensuring that minority classes are adequately represented during model training. These measures improve the reliability of the evaluation and prevent the model from being biased toward the majority class. Denote the dataset as matrix X∈ℝn×dX ^n× d, where each row corresponds to an individual observation and each column to a specific feature, such as a sensor reading or process variable. Here, n denotes the number of observations, and d the number of measured features. This matrix serves as the input to the predictive models used in this study and is structured as follows: X=[x11x12⋯x1​dx21x22⋯x2​d⋮⋱⋮xn​1xn​2⋯xn​d]X= bmatrixx_11&x_12&·s&x_1d\\ x_21&x_22&·s&x_2d\\ & & & \\ x_n1&x_n2&·s&x_nd bmatrix where xi​jx_ij is the value of the j-th feature in the i-th observation. Alongside this, the target vector Y∈ℝnY ^n holds the corresponding class labels for each observation, where Y=[y1,y2,…,yn]TY=[y_1,y_2,…,y_n]^T, and each label yi∈0,1y_i∈\0,1\, where 1 denotes a ”Success” and 0 indicates a ”Failure.” Prior to model training, several preprocessing steps are carried out on the dataset. These include: 1) Handling missing data; 2) Addressing class imbalance using techniques such as oversampling [31]; 3) Outlier detection to ensure the quality and reliability of the data. Matrix X serves as the input of the proposed model. The input data is fed into the encoder. The encoder learns to map high-dimensional input data into lower-dimensional latent space, where the most informative features are captured. During training, the decoding component ensures that the reconstruction loss is minimized. To ensure the quality of the learned representations, we employ Reconstruction Loss and Latent Variance Loss to minimize the reconstruction error and penalize excessive variation within each class’s latent space, respectively. Additionally, Dropout Regularization (DR) and Batch Normalization (BN) are applied to regularize the model and improve its generalization capabilities. DR randomly deactivates neurons during training, which prevents co-adaptation of latent features and reduces overfitting in high-dimensional settings. BN stabilizes and accelerates training by normalizing intermediate activations, thereby mitigating internal covariate shift and improving robustness to noisy sensor data. Together, these techniques are particularly important in industrial fault detection, where datasets are often noisy and prone to overfitting due to high dimensionality. The features extracted from X in the latent space are then used to train classifiers, where the goal is to optimize the prediction accuracy based on the input features. The data from X is split into training and test sets to validate the effectiveness of the models in predicting unseen data. The analysis and evaluation are carried out by using different performance metrics. To further evaluate and interpret the extracted features, we integrate a game-theory-based interpretability technique. This enables us to analyze the latent space and identify the most influential features in a fault prediction process. Input Layer Input ∈ℝdx ^dDense Layer1=σ​(1​+1)h_1=σ(W_1x+b_1) Dense Layer2=σ​(2​1+2)h_2=σ(W_2h_1+b_2) Latent Space=σ​(3​2+3)z=σ(W_3h_2+b_3) Latent RepresentationDense Layer4=σ​(4​+4)h_4=σ(W_4z+b_4) Dense Layer5=σ​(5​4+5)h_5=σ(W_5h_4+b_5) Reconstruction x Output xPrediction Layery^=fclf​() y=f_clf(z) ClassifierOutput Classy y PredictionLatentExploration Layer DR + BNDR + BNDR + BNDR + BNDR + BN Figure 2: The CLAIRE architecture. The encoder compresses the input ∈ℝdx ^d into a lower-dimensional latent representation ∈ℝkz ^k, passing through multiple dense layers. Dropout Regularization (DR) and Batch Normalization (BN) are applied after each layer to improve generalization and training stability. The decoder reconstructs the input, while the latent code is also used by a downstream classifier to predict the label y y. A dedicated Latent Exploration Layer enables interpretability analysis of z. I-B Latent Space Construction and Optimization This section outlines the steps involved in implementing the model, detailing the architecture of the hybrid approach and the construction of the cost function. Denote the training dataset as: =((i),y(i))i=1n,(i)∈ℝd,y(i)∈0,1D= \(x^(i),y^(i)) \_i=1^n, ^(i) ^d, y^(i)∈\0,1\ where each (i)x^(i) is a d-dimensional feature vector, and y(i)y^(i) is the corresponding binary label indicating success or failure. The goal is identifying most informative features by training a classifier that maps any new input x to a predicted label y^∈0,1 y∈\0,1\ using an optimized latent space. The encoding-decoding pipeline is designed to learn an efficient representation of its input data through the process of reconstruction. It is composed of two components, i.e., Encoder and Decoder. The former learns a compressed, latent representation of the input data. The latter attempts to reconstruct the original input from the latent space. We define the mentioned components as follows. • Encoder fenc​(⋅;θe):ℝd→ℝkf_enc(·; _e):R^d ^k maps the high-dimensional input ∈ℝdx ^d to a compact latent representation ∈ℝkz ^k, where k≪dk d; and • Decoder fdec​(⋅;θd):ℝk→ℝdf_dec(·; _d):R^k ^d attempts to reconstruct the original input from the latent space. Let (i)z^(i) and ^(i) x^(i) be the encoding and decoding respectively, i.e., (i)=fenc​((i);θe),^(i)=fdec​((i);θd)z^(i)=f_enc(x^(i); _e), x^(i)=f_dec(z^(i); _d) (1) where (i)x^(i) is the i-th input data point, fencf_enc is the encoding function that maps input (i)x^(i) to a lower-dimensional latent representation (i)z^(i), θe _e refers to the parameters (weights) of the encoder, which are learned during the training process. (i)z^(i) is the compressed latent representation of (i)x^(i), capturing the essential features of input data. (i)z^(i) is the latent representation generated by the encoder, and fdecf_dec is the decoding function that reconstructs the original input from the latent representation (i)z^(i). θd _d refers to the parameters or weights of the decoder like those in the encoding segment, which are also learned during the training process. ^(i) x^(i) is the reconstructed version of (i)x^(i), generated by the decoder. As mentioned, the encoder transforms (i)x^(i) into a lower-dimensional latent representation (i)z^(i), and the decoder attempts to reconstruct the original input from the latent representation. The goal during training is to minimize the reconstruction error between ^(i) x^(i) and (i)x^(i), i.e., ℒreconstruction=1n​∑i=1n‖(i)−fdec​(fenc​((i)))‖2L_reconstruction= 1n _i=1^n \|x^(i)-f_dec(f_enc(x^(i))) \|^2 (2) The architecture of CLAIRE is illustrated in Fig. 2. The encoder compresses input ∈ℝdx ^d into a lower-dimensional latent representation ∈ℝkz ^k by passing it through multiple dense layers. The parameters θe _e and θd _d of the encoder and decoder, respectively, are optimized during training using gradient descent to minimize the loss function ℒDAEL_DAE over the dataset. The encoding-decoding pipeline consists of L layers in the encoder and M layers in the decoder. The encoder performs a forward mapping from the input to the latent representation through a sequence of nonlinear transformations: (1) ^(1) =σ​((1)​+(1)) =σ(W^(1)x+b^(1)) (3) (2) ^(2) =σ​((2)​(1)+(2)) =σ(W^(2)h^(1)+b^(2)) ​⋮ 0.0pt6.45831pt =(L) =h^(L) Similarly, the decoder reconstructs the input by reversing the transformation from the latent space: (1) ^(1) =σ​(dec(1)​+dec(1)) =σ(W^(1)_decz+b^(1)_dec) (4) (2) ^(2) =σ​(dec(2)​(1)+dec(2)) =σ(W^(2)_decr^(1)+b^(2)_dec) ​⋮ 0.0pt6.45831pt x =(M) =r^(M) Let ℒ​(^,)L( x,x) denote the reconstruction loss, defined as: ℒ=12​‖−^‖2L= 12 \|x- x \|^2 (5) where x is the original input and x is the reconstructed input produced by the decoder. This loss measures the reconstruction error, i.e., how closely the model reproduces its input. The goal during training is to minimize this difference. The factor 12 12 is included for mathematical convenience during differentiation. We now derive the weight updates using the chain rule for vector-valued functions. For any layer ℓ , the gradient of the loss with respect to weights (ℓ)W^( ) is given as: ∂ℒ∂(ℓ)=∂ℒ∂(ℓ)⋅∂(ℓ)∂(ℓ) ^( )= ^( )· ^( ) ^( ) (6) Assuming that each layer consists of a linear transformation followed by a non-linear activation, we define the forward pass for the ℓ -th layer as: (ℓ)=σ​((ℓ))where ​(ℓ)=(ℓ)​(ℓ−1)+(ℓ)h^( )=σ(a^( )) a^( )=W^( )h^( -1)+b^( ) (7) Here, (ℓ)a^( ) denotes the pre-activation input to the activation function σ, and (ℓ−1)h^( -1) is the output of the previous layer. (ℓ)W^( ) and (ℓ)b^( ) are the weight and bias parameters for layer ℓ . Using the chain rule again, the derivative of the activation function with respect to the pre-activation input is: ∂(ℓ)∂(ℓ)=σ′​((ℓ)) ^( ) ^( )=σ (a^( )) (8) where σ′σ denotes the derivative of the activation function with respect to (ℓ)a^( ). In this work, we use a combination of leaky ReLU and sigmoid activations. To update the parameters of the network, we compute the gradient of the loss with respect to the weights as: ∂ℒ∂(ℓ)=(δ(ℓ)∘σ′​((ℓ)))⋅((ℓ−1))T ^( )= (δ^( ) σ (a^( )) )· (h^( -1) )^T (9) where δ(ℓ)=∂ℒ∂(ℓ)δ^( )= ^( ) is the error propagated back from the subsequent layer. The symbol ∘ denotes element-wise multiplication. Similarly, the gradient with respect to the bias is: ∂ℒ∂(ℓ)=δ(ℓ)∘σ′​((ℓ)) ^( )=δ^( ) σ (a^( )) (10) To perform optimization, the parameters θ=,θ=\W,b\ are updated via gradient descent, i.e., θ←θ−η⋅∇θℒ,θ←θ-η· _θL, where η>0η>0 is the learning rate and ∇θℒ _θL is the gradient of the loss with respect to the parameters. For the decoder, error propagation begins from the reconstruction loss. The error at the output layer is: δ(M)=∂ℒ∂^=^−δ^(M)= ∂ x= x-x (11) This error is then backpropagated layer by layer: δ(M−1)=((M))T​δ(M)∘σ′​((M−1)),…δ^(M-1)= (W^(M) )^Tδ^(M) σ (a^(M-1)), … (12) Finally, the weights and biases are updated using the computed gradients: (ℓ)←(ℓ)−η​∂ℒ∂(ℓ),(ℓ)←(ℓ)−η​∂ℒ∂(ℓ)W^( ) ^( )-η ^( ), ^( ) ^( )-η ^( ) (13) I-B1 Loss Functions As mentioned earlier, CLAIRE aims to minimize the reconstruction error between the input and its reconstructed output, while also regularizing the latent space to ensure compact and meaningful representations. To achieve this, we define two key loss functions: Reconstruction Loss and Latent Variance Loss, which together form the unsupervised loss term ℒDAEL_DAE. Reconstruction Loss quantifies the difference between the original input and output of the autoencoder, ensuring that the model effectively captures essential patterns in the data. Latent Variance Loss acts as a regularization term that encourages the latent space to remain compact by penalizing excessive variance across the latent dimensions. This discourages the model from relying on irrelevant activations and is particularly important when the latent code is used as input to downstream classifiers. It is defined as: Llatent=1k​∑j=1kVar​(zj)L_latent= 1k _j=1^kVar(z_j) (14) where zjz_j is the j-th dimension of latent code z, k is latent space dimensionality. The loss at this phase is given as: LDAE=Lreconstruction+λ​LlatentL_DAE=L_reconstruction+λ L_latent (15) where λ is a hyperparameter that balances reconstruction fidelity and latent space compactness. Minimizing this loss enables CLAIRE to extract representations that are both informative and robust to noise, thus enhancing the performance of the downstream classifier. It is important to note that this loss defines the representation learning objective used in Phase 1 of training. Additional components, including the classification loss and entropy regularization, are also incorporated into the overall optimization objective. I-B2 Optimization To ensure stable and efficient training, we adopt a momentum-based optimization approach that dynamically adjusts learning rates. The first and second moments of the gradients are computed as follows: mt m_t =β1​mt−1+(1−β1)​∇θℒ, = _1m_t-1+(1- _1) _θL, (16) vt v_t =β2​vt−1+(1−β2)​(∇θℒ)2 = _2v_t-1+(1- _2)( _θL)^2 θ θ ←θ−η⋅mtvt+ϵ ←θ-η· m_t v_t+ε where β1 _1 and β2 _2 are momentum parameters, ϵε is a small constant for numerical stability, and η is the learning rate. These updates are applied across all layers of both encoder and decoder until convergence. To reduce overfitting, we apply dropout regularization by randomly deactivating neurons during training. Let ∈ℝdh ^d be a layer’s activation. The dropout operation is defined as ~=∘, h=m , where ∈0,1dm∈\0,1\^d is a binary mask sampled from a Bernoulli distribution, i.e.,mi∼Bernoulli​(p),i=1,…,dm_i (p), i=1,…,d. During inference, activations are rescaled by using the dropout rate, i.e., test=p⋅h_test=p·h. In addition, Batch Normalization (BN) is employed to stabilize training by normalizing activations within each mini-batch. For xix_i, the transformation is: μB=1m​∑i=1mxi,σB2=1m​∑i=1m(xi−μB)2 _B= 1m _i=1^mx_i, _B^2= 1m _i=1^m(x_i- _B)^2 (17) x^i=xi−μBσB2+ϵ,yi=γ​x^i+β x_i= x_i- _B _B^2+ε, y_i=γ x_i+β (18) where m is the batch size, γ and β are learnable scale and shift parameters. BN is used to reduce internal covariate shift, improve gradient flow, and enable fast convergence. It is applied after the linear transformation and before the activation function: (ℓ)=σ​(BN​((ℓ)​(ℓ−1)+(ℓ)))h^( )=σ(BN(W^( )h^( -1)+b^( ))) (19) As shown in Fig. 2, DR and BN are applied after each dense layer in both encoder and decoder. Their integration significantly improves the training stability and generalization performance of the model. This is particularly critical when working with high-dimensional data where overfitting is a common issue. I-C Support Vector Machine with Kernel Trick After training, we discard the decoder and retain only the encoder to transform each input (i)x^(i) into its corresponding latent representation (i)z^(i). This results in a transformed dataset: =((i),y(i))i=1nZ= \(z^(i),y^(i)) \_i=1^n (20) We then train a binary Support Vector Machine (SVM) classifier on this lower-dimensional representation. SVM seeks a decision function of the form: f​()=sign​(∑i=1nαi​y(i)​K​((i),)+b)f(z)=sign ( _i=1^n _iy^(i)K(z^(i),z)+b ) (21) where αi _i is a dual coefficient, b is a bias term, and K​(⋅,⋅)K(·,·) is a kernel function satisfying the Mercer’s condition [32, 33]. SVM is trained by solving the following convex optimization problem in its dual form: min _ α 12​∑i=1n∑j=1nαi​αj​y(i)​y(j)​K​((i),(j))−∑i=1nαi 12 _i=1^n _j=1^n _i _jy^(i)y^(j)K(z^(i),z^(j))- _i=1^n _i (22) subject to ∑i=1nαi​y(i)=0,0≤αi≤C,∀i _i=1^n _iy^(i)=0, 0≤ _i≤ C, ∀ i where C>0C>0 is a regularization parameter controlling the trade-off between maximizing its margin and minimizing classification error. Note that binary labels are mapped from 0,1\0,1\ to −1,+1\-1,+1\ to match the standard SVM formulation, while in neural network training they remain 0,1\0,1\. For a new and unseen input ∗x^*, the encoder produces its latent representation ∗=fenc​(∗)z^*=f_enc(x^*), and SVM makes a prediction, i.e., y^=sign​(∑i=1nαi​y(i)​K​((i),∗)+b) y=sign ( _i=1^n _iy^(i)K(z^(i),z^*)+b ) (23) To perform classification in high-dimensional feature space without explicitly computing nonlinear transformations, we utilize the kernel trick. The kernel function implicitly defines an inner product in the transformed space: K​((i),(j))=⟨ϕ​((i)),ϕ​((j))⟩K(z^(i),z^(j))= φ(z^(i)),φ(z^(j)) (24) where ϕ​(⋅)φ(·) is an implicit nonlinear mapping, and K​(⋅,⋅)K(·,·) is a valid Mercer kernel. We conduct a comparative evaluation of four widely used kernels: 1. Linear kernel: K​(,′)=⊤​′K(z,z )=z z . It is computationally efficient but limited to linear separability. 2. Polynomial kernel: K​(,′)=(⊤​′+c)dK(z,z )=(z z +c)^d. It captures nonlinear interactions but is sensitive to feature scaling and prone to overfitting in high-dimensional space. 3. Radial Basis Function (RBF) kernel: K​(,′)=exp⁡(−γ​‖−′‖2)K(z,z )= (-γ\|z-z \|^2). It provides flexible, localized decision boundaries; robust in high-dimensional settings. 4. Sigmoid kernel: K​(,′)=tanh⁡(α​⊤​′+β)K(z,z )= ( z +β). It is inspired by neural networks but occasionally suffers from poor convergence. Among these, the RBF kernel demonstrates superior performance on the learned latent representations due to its ability to model complex, nonlinear decision boundaries. Based on our empirical findings, we thus select the RBF kernel for the final SVM classifier. Algorithm 1 realizes the full two-phase training procedure of the proposed CLAIRE framework. Algorithm 1 Two-Phase CLAIRE Framework 1:Training data =((i),y(i))i=1nD=\(x^(i),y^(i))\_i=1^n 2: where (i)∈ℝdx^(i) ^d, y(i)∈0,1y^(i)∈\0,1\ 3:Predictive model for y y from input x 4:Initialize: Encoder parameters θe _e, Decoder parameters θd _d 5:Define: Encoder fenc​(;θe)f_enc(x; _e), Decoder fdec​(;θd)f_dec(z; _d) 6:Initialize: Classifier parameters θc _c 7:Define: Classifier fclf​(;θc)f_clf(z; _c) and y^(i)=fclf​(z(i);θc) y^(i)=f_clf(z^(i); _c) 8:Define: Corruption function ​(⋅)C(·) 9:Define: Reconstruction loss: 10: ℒrecon=1n​∑i=1n‖(i)−fdec​(fenc​(~(i)))‖2L_recon= 1nΣ _i=1^n \|x^(i)-f_dec(f_enc( x^(i))) \|^2 11: where ~(i)=​((i)) x^(i)=C(x^(i)) 12:Define: Latent variance loss: 13: ℒlatent=1d​∑j=1dVar​(zj)L_latent= 1dΣ _j=1^dVar(z_j) 14: where zjz_j is the j-th latent unit 15:Define: Representation learning loss: 16: ℒDAE=ℒrecon+λ​ℒlatentL_DAE=L_recon+ _latent 17: where λ>0λ>0 is a regularization weight 18:Define: Supervised classification loss: 19: ℒclf=−1n​∑i=1n[y(i)​log⁡y^(i)+(1−y(i))​log⁡(1−y^(i))]L_clf=- 1nΣ _i=1^n [y^(i) y^(i)+(1-y^(i)) (1- y^(i)) ] 20:Define: Entropy regularization: 21: ℒent=−1n​∑i=1n[y^(i)​log⁡y^(i)+(1−y^(i))​log⁡(1−y^(i))]L_ent=- 1nΣ _i=1^n [ y^(i) y^(i)+(1- y^(i)) (1- y^(i)) ] 22:Define: Total training objective: 23: ℒTotal=ℒDAE+α​ℒclf+β​ℒentL_Total=L_DAE+ _clf+ _ent 24: where α,β>0α,β>0 are weighting coefficients 25:Define: Dropout rate p and BatchNorm function ℬ​(⋅)B(·) 26:/* Phase 1: Optimized Encoder-Decoder and Joint Representation */ 27:for epoch=1epoch=1 to N do 28: for all mini-batches (i)\x^(i)\ do 29: Corrupt input: ~(i)←​((i)) x^(i) (x^(i)) 30: Encode: (i)←fenc​(~(i);θe)z^(i)← f_enc( x^(i); _e) 31: Apply dropout: (i)←Dropout​((i),p)z^(i) (z^(i),p) 32: Apply BN: (i)←ℬ​((i))z^(i) (z^(i)) 33: Decode: ^(i)←fdec​((i);θd) x^(i)← f_dec(z^(i); _d) 34: Compute total loss ℒTotalL_Total 35: Update θe _e, θd,θc _d, _c via gradient descent 36: end for 37:end for 38:/* Phase 2: Training an SVM on Frozen Latent Representations; */ 39:Generate latent dataset: =(fenc​((i)),y(i))i=1nZ=\(f_enc(x^(i)),y^(i))\_i=1^n 40:Train SVM by solving: 41: min⁡12​∑i,jαi​αj​y(i)​y(j)​K​((i),(j))−∑iαi _ α 12 _i,j _i _jy^(i)y^(j)K(z^(i),z^(j))- _i _i 42: subject to ∑iαi​y(i)=0,0≤αi≤C _i _iy^(i)=0, 0≤ _i≤ C 43:/* Inference */ 44:Given: new test input ∗x^* 45:Compute latent code: ∗=fenc​(∗)z^*=f_enc(x^*) 46:Predict label: 47: y^=sign​(∑i=1nαi​y(i)​K​((i),∗)+b) y=sign ( _i=1^n _iy^(i)K(z^(i),z^*)+b ) I-D Interpreting Latent Representations To improve the transparency of CLAIRE and explain the internal decision logic, we introduce a post hoc interpretability phase based on a game-theoretic approach. Specifically, we apply SHapley Additive exPlanations to encoder to assess how individual input features influence latent space. This process enables us to analyze which features drive the learned latent representations. Algorithm 2 Latent Space Interpretation 1:Trained CLAIRE model, input data train,testX_train,X_test 2:SHAP values explaining feature contributions to latent dimensions 3:Step 1: Wrap encoder into a standalone model Define: ​fenc​()←Encoder module from trained CLAIREDefine: f_enc(x) module from trained CLAIRE 4:Step 2: Select representative background samples bg←First ​k​ samples from ​trainX_bg k samples from X_train 5:Step 3: Define SHAP masker masker←shap.maskers.Independent​(bg)masker← shap.maskers.Independent(X_bg) 6:Step 4: Create SHAP explainer explainer←shap.Explainer​(fenc,masker)explainer← shap.Explainer(f_enc,masker) 7:Step 5: Compute SHAP values for test data test′←First ​m​ samples from ​testX_test m samples from X_test shap_values←explainer​(test′)shap\_values (X_test ) 8:Step 6: Visualize beeswarm plots for selected latent dimensions shap.plots.beeswarm​(shap_values​[:,:,i]) shap.plots.beeswarm(shap\_values[:,:,i]) 9: i = 1 …4 Algorithm 2 computes SHAP values for each latent dimension of encoder. The SHAP plots reveal which input features most strongly influence the learned latent space across the input. Such interpretability is essential in real-world industrial settings, where understanding feature importance can inform root cause analysis, domain expert validation, and regulatory compliance. IV Experimental Results This section presents the experimental results obtained from training and evaluating the proposed CLAIRE. We investigate the influence of several hyperparameters, such as the number of neurons and layers, mini-batch size, learning rate, and loss function components, on model performance. In addition, we compare CLAIRE’s classification performance with a traditional baseline and analyze the learned latent representations. IV-A Effect of Architectural and Training Choices The architecture plays a crucial role in learning meaningful feature representations. We experiment with different layer and neuron counts, ultimately selecting an encoder with two layers of 128 and 64 neurons, mirrored by the decoder. Increasing the number of neurons tends to improve both reconstruction and classification accuracy by enabling the model to capture more complex patterns. However, deeper models exhibit the signs of overfitting, as reflected in the increased variance of loss values across epochs. Conversely, reducing neurons leads to underfitting where the model fails to capture key characteristics of the data. These results underscore the importance of architectural balance. In addition, we observe that excessively deep or wide architectures tend to destabilize the latent variance regularization term, leading to less compact embeddings despite improved reconstruction, further motivating a balanced architectural design. We evaluate mini-batch sizes of 32 and 64. The former introduces higher gradient variance, resulting in noisier updates and slower convergence. The latter requires much more memory than the former. It improves convergence stability and training efficiency. Therefore, we adopt a mini-batch size of 64. This choice also contributes to more stable optimization of the latent variance regularization by reducing stochastic fluctuations in latent statistics across batches. We emphasize that the choice of mini-batch sizes is guided by practical considerations commonly adopted in industrial deep learning applications. Very small batch sizes tend to introduce excessive gradient noise and unstable latent statistics, while substantially larger batches offer diminishing returns in convergence quality and incur unnecessary memory and computational overhead. Preliminary trials with larger batch sizes did not yield measurable improvements in reconstruction accuracy, classification performance, or latent compactness. Consequently, the selected range represents a balanced and practically sufficient operating regime rather than an exhaustive hyperparameter search. For optimization, we test the learning rates of 1×10−21× 10^-2 and 1×10−31× 10^-3. The latter provides smooth convergence with consistent loss reduction, whereas the former introduces instability despite faster early training. As a result, 1×10−31× 10^-3 is selected for final training. Overall, these architectural and training choices jointly ensure stable convergence behavior while preserving the discriminative and compact structure of the learned latent space. IV-B Loss Function Behavior and Regularization CLAIRE’s objective combines multiple losses: reconstruction, classification, latent variance regularization, and entropy regularization. The reconstruction loss ensures faithful input reconstruction, while the classification one improves prediction performance. Latent variance loss encourages compact representations. The entropy regularization loss prevents overconfident predictions. From an optimization perspective, the latent variance regularization acts as a geometry-shaping constraint that gradually reduces the dispersion of latent embeddings without dominating the reconstruction objective. We apply Dropout Regularization (rate 0.3) and Batch Normalization (momentum 0.9) after each dense layer to improve generalization and stability. These regularization mechanisms further mitigate overfitting and help stabilize the interaction between reconstruction and latent compactness objectives during training. Fig. 3 shows the convergence curves across 80 training epochs on the SECOM dataset. The representation learning loss, the classification loss, and entropy-based regularization are plotted in their non-weighted forms to illustrate convergence behavior, while the total loss reflects their weighted aggregation during training. Due to loss weighting, normalization effects (Batch Normalization), and Dropout Regularization, the total loss magnitude is not directly comparable to the standalone terms. The total loss decreases rapidly during the first 30 epochs and then stabilizes. Classification and entropy regularization losses converge after around 20–30 epochs, while the reconstruction and latent variance losses converge early. Notably, the early stabilization of the latent variance loss indicates that compact latent structures are established in the initial training phase and remain stable thereafter. These trends suggest that meaningful convergence is achieved within 40 epochs, allowing us to reduce training time without performance loss. Consequently, we fix the number of epochs at 40 in the final implementation. For the TEP dataset, we keep all hyperparameters approximately the same, except for reducing the number of epochs to 30 due to its smaller number of features and faster convergence. This consistency across datasets further confirms the robustness of the proposed training strategy. Figure 3: Loss convergence over training epochs on the SECOM dataset. IV-C Comparative Evaluation We have benchmarked the proposed model against several baseline approaches to assess its effectiveness. In addition to a traditional Support Vector Machine (SVM) with an RBF kernel trained directly on raw features, we have also included representation-learning-based models, i.e., a standard Autoencoder (AE), a Variational Autoencoder (VAE), and a β-VAE, trained on both SECOM and TEP. These models are selected as baselines because they are capable of mapping the input features into lower-dimensional latent spaces, which allows a fair comparison with our proposed method that also relies on learning discriminative latent representations. Each of these baselines have been implemented by using the same data preprocessing pipeline, initialization strategy, and training protocol to eliminate biases introduced by differing experimental conditions. In addition, hyperparameters such as learning rate, batch size, latent dimensionality, and dropout rate have been tuned individually for each model through empirical validation. This ensures that all baselines operate under optimized yet comparable conditions. The AE serves as a deterministic reconstruction-based baseline, while the VAE introduces probabilistic latent variable modeling with Kullback–Leibler (KL) divergence regularization. The β-VAE has extended the VAE framework by scaling the KL term with a factor β>1β>1, thereby encouraging more disentangled latent representations. By including these variants, the evaluation captures both deterministic and probabilistic reconstruction paradigms, as well as a disentanglement-oriented extension. Overall, the design and tuning of these baselines provide a robust foundation for evaluation, ensuring that performance improvements observed in the proposed model are attributable to its methodological contributions. Table I shows that CLAIRE significantly outperforms all baselines in both accuracy and F1 score, highlighting the advantage of its learned latent features in capturing class-discriminative structure. TABLE I: Performance comparison of all baseline models and the proposed method (CLAIRE) on the SECOM and TEP datasets. SECOM Dataset Model Accuracy F1 Score SVM (RBF kernel) 0.84 0.84 AE 0.86 0.86 VAE 0.85 0.84 β-VAE 0.83 0.82 CLAIRE (Proposed) 0.94 0.93 TEP Dataset Model Accuracy F1 Score SVM (RBF kernel) 0.84 0.82 AE 0.84 0.84 VAE 0.82 0.83 β-VAE 0.86 0.86 CLAIRE (Proposed) 0.92 0.92 IV-D Latent Space Visualization To further assess the learned latent space, we apply t-distributed Stochastic Neighbor Embedding (t-SNE) to project the high-dimensional latent codes into 3D for visualization. Fig. 4(a) provides a comparative visualization of the latent spaces learned by CLAIRE and three baseline models (AE, VAE, and β-VAE) on SECOM (samples are color-coded by class label). While the baseline models produce largely overlapping representations, CLAIRE exhibits a clearer spatial separation between the two classes. Fig. 4(b) presents the Linear Discriminant Analysis (LDA) projections, together with Gaussian density estimates. The class means (μ0 _0, μ1 _1), discriminant threshold τ, and the separability index d′d are also shown. The results reveal that CLAIRE achieves the highest d′d value (d′=4.03d =4.03), indicating significantly stronger class discrimination, whereas the baseline models demonstrate substantially weaker separation (with their d′<0.5d <0.5). This confirms the advantage of CLAIRE in producing more structured and discriminative latent representations. The resulting clusters are well-separated, with minimal overlap between two classes, indicating that CLAIRE learns highly discriminative latent representations. This clear separation supports the impact of latent variance regularization in promoting compact, class-specific encoding. The latent structure not only improves reconstruction and classification, but also reveals internal structure aligned with decision boundaries. Similarly, for TEP, the LDA projections of the learned latent features (Fig. 5) also show clear separation between classes. CLAIRE achieves a substantially higher separability index than all baseline models, indicating that the same discriminative latent representation is consistently observed on this dataset as well. Figure 4: Visualization of latent representations for SECOM. a) Three-dimensional t-SNE embeddings for four models: (I) CLAIRE, (I) Standard Autoencoder (AE), (I) Variational Autoencoder (VAE), and (IV) β-VAE. Each point represents a sample colored by its class label (blue: Class 0, red: Class 1). b) LDA one-dimensional projections of latent spaces. Histograms and Gaussian fits illustrate the class distributions, with vertical dashed lines marking class means (μ0 _0, μ1 _1) and solid black lines indicating the discriminant threshold τ. The reported d′d values quantify the separation between classes, highlighting the superior discriminability of CLAIRE compared to baseline models. Figure 5: LDA one-dimensional projections of the latent representations obtained for TEP. CLAIRE demonstrates a substantially larger separation compared to the baseline models. IV-E Explaining Latent Representations via a Game-Theoretic Technique To interpret the internal behavior of CLAIRE, we apply a game-theory-based interpretability technique by using SHapley Additive exPlanations (SHAP). Given that the encoder is responsible for transforming high-dimensional sensor data into a compact latent representation, we isolate the encoder subnetwork and treat it as a standalone model. Using SHAP, we compute how each input feature contributes to variations in each latent dimension. A representative subset of the training data is used as the background distribution. SHAP values are then computed on test inputs to assess the marginal contribution of each input feature to the encoder’s output. This approach allows us to understand how perturbations in raw input data affect the learned latent representations, offering a window into the model’s internal structure. The importance of input features in SHAP analysis is conventionally quantified by the mean absolute SHAP value across all samples, defined as Importance​(fi)=1N​∑j=1N|S^i,j|,Importance(f_i)= 1N _j=1^N | S_i,j |, where S^i,j S_i,j denotes the SHAP attribution of feature fif_i for sample j. A higher value of this metric indicates that the corresponding feature exerts a stronger influence on the model’s output (in this case, the latent representation or the classification outcome). For SECOM, Fig. 6 shows SHAP plots for four selected latent dimensions. Each point represents a feature’s SHAP value for an individual sample. It is important to note that the sign of SHAP values provides additional interpretability, i.e., positive attributions (depicted in red) indicate that the feature increases the latent dimension’s activation for a given instance, whereas negative ones (depicted in blue) indicate that the feature decreases it. Hence, the color distribution across samples reflects the direction of feature contributions, while the magnitude of the mean absolute SHAP values is the primary determinant of global feature importance. These plots reveal which input features have the greatest influence on each latent unit. For example, in Fig. 6(a), Features 13, 5, and 4 are the most influential contributors to Latent Dimension 0. In Fig. 6(b), Feature 13 stands out again. Together with Features 5 and 61, they play a significant role in Dimension 5. In Dimension 10 (Fig. 6(c)), Features 13, 24, and 15 are the top contributors. Feature 13 again emerges as influential in Dimension 15, alongside Features 12, 88, and 80 (Fig. 6(d)). To assess global feature importance, we have aggregated the mean absolute SHAP values across all latent dimensions and test samples. Table I lists the top 10 input features ranked by their average contribution to the latent space. These globally dominant features consistently influence multiple latent dimensions, underscoring their critical role in CLAIRE’s representation learning process. We use 64 latent dimensions for this analysis on SECOM due to its large number of input features, while for TEP, the same analysis is performed with 32 latent dimensions given its smaller feature set. Table IV lists the top 10 input features for TEP. (a) Latent Dimension 0 (b) Latent Dimension 5 (c) Latent Dimension 10 (d) Latent Dimension 15 Figure 6: SHAP plots for the SECOM dataset, illustrating the most influential input features across four selected latent dimensions. TABLE I: Top 10 globally important input features for the SECOM dataset, ranked according to their mean SHAP values (MSV) across all 64 latent dimensions. Rank Index SHAP Dim. 0 SHAP Dim. 1 … SHAP Dim. 64 MSV 1 Feature 13 0.0801 0.0283 … 0.0302 0.0380 2 Feature 5 0.0712 0.0558 … 0.0310 0.0368 3 Feature 24 0.0510 0.0212 … 0.0291 0.0356 4 Feature 12 0.0604 0.0273 … 0.0306 0.0286 5 Feature 15 0.0583 0.0241 … 0.0148 0.0282 6 Feature 39 0.0470 0.0207 … 0.0201 0.0267 7 Feature 88 0.0562 0.0164 … 0.0222 0.0264 8 Feature 48 0.0452 0.0162 … 0.0092 0.0262 9 Feature 21 0.0360 0.0266 … 0.0128 0.0260 10 Feature 80 0.0241 0.0141 … 0.0201 0.0241 TABLE IV: Top 10 globally important input features for the TEP dataset, ranked based on their MSVs across all 32 latent dimensions. Rank Index SHAP Dim. 0 SHAP Dim. 1 … SHAP Dim. 32 MSV 1 Feature 17 0.0593 0.1040 … 0.1002 0.1004 2 Feature 49 0.0543 0.0768 … 0.0746 0.0752 3 Feature 51 0.0821 0.0614 … 0.0622 0.0641 4 Feature 50 0.0422 0.0483 … 0.0510 0.0479 5 Feature 12 0.0272 0.0414 … 0.0415 0.0424 6 Feature 16 0.0796 0.0409 … 0.0401 0.0417 7 Feature 6 0.0339 0.0320 … 0.0309 0.0314 8 Feature 45 0.0228 0.0281 … 0.0280 0.0299 9 Feature 10 0.0203 0.0290 … 0.0291 0.0283 10 Feature 43 0.0213 0.0278 … 0.0247 0.0264 We next identify the true root causes of faults by finding which input features are statistically responsible for failure instances (Class 1). To do so, we extract importance values specifically for predictions labeled as failures. This allows us to identify features that exhibit substantially higher SHAP values in failure samples (Class 1) compared to successful samples (Class 0). We have found that Features 13, 24, and 12, consistently show high SHAP values for faulty predictions on SECOM. Beyond individual feature contributions, SHAP dependence plots enable the analysis of feature interactions, where the effect of one feature is conditioned on the value of another. Fig. 7 presents a SHAP dependence plot for Feature 13, one of the most influential variables in predicting failure instances, showing that its SHAP values generally increase with larger feature values, suggesting a stronger positive contribution to latent space. Specifically, instances with high values of Feature 26 (depicted in red) display predominantly positive SHAP values for Feature 13, whereas instances with low values of Feature 26 (depicted in blue) exhibit neutral or negative SHAP contributions. This observation indicates that the impact of Feature 13 is not independent, but rather strongly modulated by Feature 26. A positive SHAP value suggests that higher readings of Feature 13 increase the likelihood of the product being classified as faulty. The color gradient corresponds to the values of Feature 26, revealing a strong interaction effect: the impact of Feature 13 intensifies when Feature 26 is also high. Such behavior suggests a compound effect where co-occurring elevated readings from both features may reflect underlying failure conditions in the manufacturing process. For TEP, Feature 17 is identified as the most influential variable for predicting Class 1 instances. The dependence plot in Fig. 8 illustrates the relationship between this feature and its SHAP values, with color coding reflecting the values of Feature 18. The color distribution highlights a strong interaction with Feature 18. Samples with low values of Feature 18 (depicted in blue) exhibit more negative SHAP contributions from Feature 17, whereas samples with high values of Feature 18 (depicted in red) show less pronounced decreases. This observation indicates that the effect of Feature 17 is not independent but modulated by Feature 18, thereby exemplifying a compound effect between the two variables. Such insights, which go beyond global importance rankings, are critical for identifying and interpreting process-level interactions that contribute to quality degradation. By systematically uncovering these compound effects, CLAIRE enables practitioners to move from abstract model interpretability toward actionable process knowledge. This reinforces the framework’s potential not only as a predictive tool but also as a diagnostic aid for complex industrial systems. The consistently dominant features and compound interaction patterns revealed by the latent exploration, such as feature pairs that jointly exert strong influence across multiple latent dimensions, represent precisely the type of diagnostic signals that can be leveraged in practice when domain knowledge is available. In real industrial deployments, where sensor metadata and process semantics are known, such interaction patterns can be interpreted by domain experts to associate latent behaviors with known fault modes or abnormal operating conditions. In this sense, the proposed interpretability layer is best viewed as a foundational bridge between representation learning and domain-level diagnosis, enabling the transition from statistical explanations to actionable process knowledge when combined with expert insight. Figure 7: SHAP dependence plot for Feature 13 on the SECOM dataset, with color coding based on Feature 26. The plot demonstrates how changes in Feature 13 influence the model’s latent representation, while also revealing interaction effects that are modulated by Feature 26. Figure 8: SHAP dependence plot for Feature 17 on the TEP dataset, with color coding by Feature 18. The figure highlights interaction effects that are further modulated by Feature 18. V Conclusions and Future Work This paper has presented CLAIRE, a hybrid end-to-end learning framework that integrates unsupervised deep representation learning with supervised classification for intelligent fault detection in industrial systems. The core of the architecture is an optimized encoding-decoding process that projects raw sensor data into a compact and structured latent space. By incorporating variance-aware reconstruction loss and latent regularization, CLAIRE captures subtle feature dependencies while mitigating the impact of noise and redundancy. The latent representations are passed to a kernel-based classifier. Empirical results demonstrate the superiority of the proposed model. In addition to robust feature extraction, CLAIRE addresses the interpretability challenge commonly associated with deep learning. A game-theoretic interpretability module is integrated to analyze latent space. This enables the identification of the most informative input features and their interactions, offering transparency in model behavior, which is an essential requirement in industrial environments. The insights gained from latent space not only support accurate fault prediction but also help reveal the root causes of quality degradation by attributing predictions to statistically relevant features. These properties make CLAIRE a practical and explainable AI-based solution for smart manufacturing. While the present study emphasizes an application-driven and empirically validated framework, a promising direction for future work lies in developing a formal theoretical characterization of latent variance regularization. Such theoretical developments would complement the empirical findings reported here and further strengthen the understanding of geometry-aware regularization mechanisms for industrial representation learning. Our future work also aims to extend this framework to handle multi-class and multi-label scenarios, as well as explore domain adaptation techniques [34] for cross-factory generalization. The underlying idea of CLAIRE is also transferable to other domains, including healthcare, energy systems, and autonomous monitoring, where data complexity and explainability are equally critical. References [1] D. -X. Huang et al., ”Real-Time 2D/3D Registration via CNN Regression and Centroid Alignment,” IEEE Trans. on Automation Science and Engineering, vol. 22, p. 85-98, 2025. [2] J. Tang, Q. Kang, M. Zhou, H. Yin and S. Yao, ”MemeNet: Toward a Reliable Local Projection for Image Recognition via Semantic Featurization,” IEEE Trans. on Image Processing, vol. 33, p. 1670-1682, Feb. 2024. [3] Z. Lei, S. Gao, H. Hasegawa, Z. Zhang, M. Zhou and K. Sedraoui, ”Fully Complex-Valued Gated Recurrent Neural Network for Ultrasound Imaging,” IEEE Trans. on Neural Networks and Learning Systems, vol. 35, no. 10, p. 14918-14931, Oct. 2024. [4] Z. Tan, J. Chen, Q. Kang, M. Zhou, A. Abusorrah and K. Sedraoui, ”Dynamic Embedding Projection-Gated Convolutional Neural Networks for Text Classification,” IEEE Trans. on Neural Networks and Learning Systems, vol. 33, no. 3, p. 973-982, March 2022. [5] H. Liu, M. Zhou and Q. Liu, ”An embedded feature selection method for imbalanced data classification,” IEEE/CAA Journal of Automatica Sinica, vol. 6, no. 3, p. 703-715, May 2019. [6] Y. Hochma, Y. Felendler and M. Last, ”Efficient Feature Ranking and Selection Using Statistical Moments,” IEEE Access, vol. 12, p. 105573-105587, 2024. [7] A. K. Mandal, M. Nadim, H. Saha, T. Sultana, M. D. Hossain and E. -N. Huh, ”Feature Subset Selection for High-Dimensional, Low Sampling Size Data Classification Using Ensemble Feature Selection With a Wrapper-Based Search,” IEEE Access, vol. 12, p. 62341-62357, 2024. [8] S. Lee, H. Park and H. -C. Kim, ”Fraud Detection on Crowdfunding Platforms Using Multiple Feature Selection Methods,” IEEE Access, vol. 13, p. 40133-40148, 2025. [9] J. Lin, Q. Chen, B. Xue and M. Zhang, ”Evolutionary Multitasking for Multiobjective Feature Selection in Classification,” IEEE Trans. on Evolutionary Computation, vol. 28, no. 6, p. 1852-1866, Dec. 2024. [10] Z. Li, F. Nie, D. Wu, Z. Hu and X. Li, ”Unsupervised Feature Selection With Weighted and Projected Adaptive Neighbors,” IEEE Trans. on Cybernetics, vol. 53, no. 2, p. 1260-1271, Feb. 2023. [11] M. Ghahramani, Y. Qiao, M.C. Zhou, A. Ohagan, and J. Sweeney, ”AI-based Modeling and Data-driven Evaluation for Smart Manufacturing Processes,” IEEE/CAA Journal of Automatica Sinica, 2021. [12] L. Chen, Y. Qiao, N. Wu, M. Ghahramani, Y. Shao and S. Zhan, ”Workload Balancing for Photolithography Machines in Semiconductor Manufacturing via Estimation of Distribution Algorithm Integrating Kmeans Clustering,” IEEE Trans. on Systems, Man, and Cybernetics: Systems, vol. 55, no. 8, p. 5565-5580, Aug. 2025. [13] Q. Deng et al., ”Evolutionary Algorithm Based on Surrogate and Inverse Surrogate Models for Expensive Multiobjective Optimization,” IEEE/CAA Journal of Automatica Sinica, vol. 12, no. 5, p. 961-973, May 2025. [14] M. Ghahramani, Y. Qiao, N. Wu and M. Zhou, ”A Multi-objective Optimization Approach for Feature Selection in Gentelligent Systems,” IEEE Internet of Things Journal, 2025, doi: 10.1109/JIOT.2025.3629076. [15] S. Liu, H. Wang, W. Peng and W. Yao, ”A Surrogate-Assisted Evolutionary Feature Selection Algorithm With Parallel Random Grouping for High-Dimensional Classification,” IEEE Trans. on Evolutionary Computation , vol. 26, no. 5, p. 1087-1101, Oct. 2022. [16] B. Ahadzadeh, M. Abdar, F. Safara, A. Khosravi, M. B. Menhaj and P. N. Suganthan, ”SFE: A Simple, Fast, and Efficient Feature Selection Algorithm for High-Dimensional Data,” IEEE Trans. on Evolutionary Computation, vol. 27, no. 6, p. 1896-1911, Dec. 2023. [17] W. Fan, K. Liu, H. Liu, Y. Ge, H. Xiong and Y. Fu, ”Interactive Reinforcement Learning for Feature Selection With Decision Tree in the Loop,” IEEE Trans. on Knowledge and Data Engineering, vol. 35, no. 2, p. 1624-1636, 1 Feb. 2023. [18] S. Yasutomi and T. Tanaka, ”Style Feature Extraction Using Contrastive Conditioned Variational Autoencoders With Mutual Information Constraints,” IEEE Trans. on Knowledge and Data Engineering, vol. 37, no. 5, p. 3001-3014, May 2025. [19] C. Wang, K. Sheng, Z. Liu, J. Wang and M. Wang, ”Incipient Fault Detection Based on Multiscale Time Series Feature Extraction,” IEEE Trans. on Instrumentation and Measurement , vol. 74, p. 1-10, 2025. [20] B. Tu, X. Liao, Q. Li, C. Zhou and A. Plaza, ”Multi-resolution Pyramid Enhanced Non-local Feature Extraction for Hyperspectral Classification,” IEEE Journal of Selected Topics in Applied Earth Observations and Remote Sensing, vol. 15, p. 5865-5879, 2022. [21] M. Yan, N. Jiang and N. Li, ”A Weighted Representation Learning Based Feature Extraction Model for Multivariate Time Series Data in the Wind Turbine PHM System,” IEEE Sensors Journal, vol. 22, no. 9, p. 8715-8727, 1 May, 2022. [22] J. Xiao, C. Liu, X. Wang, Z. Wang and X. Wu, ”A Fault Diagnosis Method for Variable Condition Equipment Based on Knowledge Transfer and Improved Residual Neural Networks,” IEEE Trans. on Instrumentation and Measurement, vol. 74, p. 1-16, 2025. [23] R. Meng et al., ”Physical-Layer Authentication Based on Hierarchical Variational Autoencoder for Industrial Internet of Things,” IEEE Internet of Things Journal, vol. 10, no. 3, p. 2528-2544, Feb. 1, 2023. [24] Z. K. Shahid, S. Saguna and C. Ahlund, ”Variational Autoencoders for Anomaly Detection and Transfer Knowledge in Electricity and District Heating Consumption,” IEEE Trans. on Industry Applications, vol. 60, no. 5, p. 7437-7450, Sept. 2024. [25] Y. Cho, D. Lee, Y. Hyun and W. Kim, ”Anomaly Detection via a Bottleneck Structure Robust to Noise in In-Distribution Samples,” IEEE Access, vol. 12, p. 130264-130270, 2024. [26] R. Chang, Y. Ma, W. Nie, J. Nie, Y. Zhu and A. -A. Liu, ”Causal Disentanglement-Based Hidden Markov Model for Cross-Domain Bearing Fault Diagnosis,” IEEE Trans. on Neural Networks and Learning Systems, vol. 36, no. 8, p. 13968-13982, Aug. 2025. [27] G. Li, F. Peng, Z. Wu, S. Wang and R. Y. D. Xu, ”ODCL: An Object Disentanglement and Contrastive Learning Model for Few-Shot Industrial Defect Detection,” IEEE Sensors Journal, vol. 24, no. 11, p. 18568-18577, 1 June, 2024. [28] Y. S. Cho and S. B. Kim, ”Supervised Contrastive Learning for Multisensor Signals Classification in Automobile Engine Manufacturing,” IEEE Trans. on Industrial Informatics, vol. 20, no. 5, p. 7764-7776, May 2024. [29] F. Hu, H. -T. Zhang, B. Xu and J. Wang, ”Self-Supervised Koopman Operator-Learning of Nonlinear Multi-Agent Systems With Partial Information,” IEEE Trans. on Circuits and Systems I: Regular Papers, 2025, doi: 10.1109/TCSI.2025.3587047. [30] I. Lomov, M. Lyubimov, I. Makarov, and L. E. Zhukov, ”Fault detection in Tennessee Eastman process with temporal deep learning models”, Journal of Industrial Information Integration, vol. 23, 2021. [31] S. Yan, Z. Zhao, S. Liu and M. Zhou, ”BO-SMOTE: A Novel Bayesian-Optimization-Based Synthetic Minority Oversampling Technique,” IEEE Trans. on Systems, Man, and Cybernetics: Systems, vol. 54, no. 4, p. 2079-2091, April 2024. [32] P. Zhang, S. Shu, and M. Zhou, “An online fault detection model and strategies based on SVM-grid in clouds,” IEEE/CAA J. of Automatica Sinica, 5(2), p. 445-456, March 2018. [33] Q. Kang, L. Shi, M. Zhou, X. Wang, Q. Wu, and Z. Wei, “A Distance-based Weighted Undersampling Scheme for Support Vector Machines and its Application to Imbalanced Classification,” IEEE Trans. on Neural Networks and Learning Systems, 29(9), p. 4152 – 4165, Sept. 2018. [34] S. Yao, Q. Kang, M. Zhou, M. J. Rawa and A. Albeshri, ”Discriminative Manifold Distribution Alignment for Domain Adaptation,” IEEE Trans. on Systems, Man, and Cybernetics: Systems, vol. 53, no. 2, p. 1183-1197, Feb. 2023. Mohammadhossein Ghahramani (Senior Member, IEEE) obtained his Ph.D. in Computer Technology and Application from Macau University of Science and Technology in 2018. He was a member of the Insight Centre for Data Analytics and a Research Fellow at University College Dublin, Ireland. Currently, he is an Assistant Professor of Data Science at Birmingham City University, UK. His research interests include smart systems, artificial intelligence, optimization, smart cities, and IoT. Dr Ghahramani has published numerous papers in reputable journals and has received several awards. He serves as a co-chair of the IEEE SMCS Technical Committee on AI-based Smart Manufacturing Systems and as an Associate Editor of IEEE Internet of Things Journal. MengChu Zhou (S’88-M’90-SM’93-F’03)(Fellow, IEEE) received his Ph. D. degree from Rensselaer Polytechnic Institute, Troy, NY in 1990 and then joined New Jersey Institute of Technology where he has been Distinguished Professor since 2013. His interests are in Petri nets, automation, robotics, big data, Internet of Things, cloud/edge computing, and AI. He has 1400+ publications including 17 books, 900+ journal papers (700+ in IEEE transactions), 31 patents and 32 book-chapters. He is Fellow of IFAC, AAAS, CAA and NAI.