CNN–Transformer–KAN: A Hybrid Deep-Learning Framework with an Inspectable KAN Classification Head for Industrial Process Fault Diagnosis

Abstract

Detecting and identifying faults in industrial chemical plants is essential for safe and stable operation, and modern monitoring systems increasingly rely on deep learning to classify faults from multivariate sensor data. A practical obstacle to adoption is trust: most deep-learning diagnosers reach their decisions through a classification layer that operators cannot inspect, making it hard to see how the model maps process signals to a particular fault. This study targets fault diagnosis on the Tennessee Eastman (TE) process, a standard benchmark of simulated chemical-plant sensor data, and asks whether this final decision stage can be made directly inspectable without sacrificing accuracy. We propose CNN–Transformer–KAN (CTKAN), a hybrid model that learns local temporal patterns with a one-dimensional convolutional encoder, captures global inter-time-step dependencies with a Transformer encoder, and classifies faults with a Kolmogorov–Arnold Network (KAN) head whose learnable B-spline activations can be plotted and examined individually, in place of a conventional multi-layer perceptron (MLP). On the TE benchmark, CTKAN attains a Macro-F1 of 91.38 ± 0.26% over ten independent runs, comparable to a CNN + Transformer + MLP ablation (91.21 ± 0.32%) and a capacity-matched MLP-head variant (91.43 ± 0.37%) within seed-to-seed variability. The main finding is therefore not a higher score: at matched capacity the KAN and MLP heads are statistically indistinguishable in accuracy, so the KAN head’s value is to add a directly inspectable view of the classification stage at no measurable accuracy cost, helping process engineers sanity-check how the diagnoser separates faults in safety-critical settings.

1. Introduction

Industrial chemical processes such as petroleum refining, pharmaceutical manufacturing, and polymerization operate under complex, highly coupled conditions where equipment failures or process deviations can lead to catastrophic consequences including environmental contamination, economic losses, and threats to human safety [1,2]. In Industry 4.0 and smart manufacturing settings, data-driven process monitoring and fault diagnosis support predictive maintenance and safer plant operation [3,4,5,6,7,8]. The TE process, originally proposed by Downs and Vogel [9] as a realistic simulation of an industrial chemical plant, has become the most widely adopted benchmark for evaluating fault diagnosis algorithms. The TE process involves five major unit operations with 41 measured and 11 manipulated variables (52 in total); our experiments use 50 process variables after standard preprocessing, encompassing 20 distinct fault scenarios of varying difficulty that span step changes, random variations, slow drifts, and sticking valves.

Traditional fault diagnosis methods based on multivariate statistical analysis, such as principal component analysis (PCA) [10] and Partial Least Squares (PLS) [11], project high-dimensional process data into lower-dimensional subspaces and monitor statistical indices for anomaly detection. While these methods are mathematically well-founded and computationally efficient, they rely on linear assumptions that fundamentally limit their ability to capture the nonlinear dynamics inherent in complex chemical processes.

The advent of deep learning has provided powerful alternatives for nonlinear feature extraction from process monitoring data, with broad adoption across machine health monitoring pipelines [12]. One-dimensional convolutional neural networks (CNN1Ds) [13,14] apply local receptive fields to capture short-range temporal patterns such as transient spikes and sensor anomalies. However, standard CNN1Ds with small kernel sizes have limited receptive fields and cannot directly model long-range dependencies across distant time steps. Recurrent Neural Networks (RNNs), particularly Long Short-Term Memory (LSTM) networks [15], process sequential data step by step and can theoretically capture long-term dependencies, but in practice suffer from vanishing gradient problems and cannot be parallelized during training. Bidirectional variants have been applied to chemical-process fault diagnosis with improved performance [16]. The Transformer architecture [17], which employs self-attention mechanisms to directly compute pairwise relationships between all time steps, has shown promising results on TE fault diagnosis [18,19,20,21]. However, applying Transformers alone sacrifices the inductive bias for local pattern extraction that CNNs provide.

Several hybrid approaches have been explored. CNN-LSTM models combine local feature extraction with sequential modeling [22], while attention-based hybrids for process monitoring continue to evolve [20,21]. Kai et al. [23] benchmark MLP, CNN, LSTM, and Transformer models on multiple chemical-process benchmarks under varying temporal subsequence lengths. However, a fundamental limitation persists: their classification layers, typically multi-layer perceptrons (MLPs) with fixed activation functions, act as opaque decision boundaries that provide no insight into how extracted features map to fault categories. In safety-critical industrial applications, operators need not only accurate predictions but also explanations of the diagnostic reasoning [24,25]. When the decision behavior of the classification layer itself can be inspected, engineers and operators can verify how the diagnoser responds to individual process variables and audit the model before trusting its outputs in safety-critical operation, rather than relying on aggregate accuracy alone.

The recently proposed KAN [26] offers a promising direction for classification heads with directly plottable edge functions. Based on the Kolmogorov–Arnold representation theorem [27], KAN replaces fixed activation functions with learnable B-spline functions on network edges, enabling direct visualization of the learned nonlinear transformations. Recent applications of KAN to fault diagnosis in power Transformers [28] and rotating machinery [29] have demonstrated its potential. Preliminary studies have also explored KAN-based autoencoders for unsupervised fault detection on the TE process [30].

To address the dual challenges of multi-scale temporal feature extraction and limited classification-layer inspectability, this paper proposes CTKAN, a three-stage hybrid architecture. The central research question we investigate is whether a KAN-based classification head can provide useful, directly inspectable decision functions for industrial fault diagnosis without reducing classification accuracy compared with a conventional MLP head. CTKAN is organized into three stages:

Stage 1 (Local Feature Extraction): A CNN1D encoder with standard convolutions and a kernel size of three extracts local temporal features. With two CNN blocks (each containing two 1D convolutional layers), the receptive field covers approximately nine time steps, capturing short-range patterns while intentionally leaving global temporal structure for the subsequent stage.

Stage 2 (Global Dependency Modeling): A Transformer encoder with multi-head self-attention establishes dependencies across all time steps, complementing the CNN’s local view with global context.

Stage 3 (Inspectable Classification): A KAN classification head with two layers of learnable B-spline activation functions replaces the conventional MLP, enabling visualization of the nonlinear response curves learned during classification. Here, by inspectability, we mean that each learned activation function in the classification layer can be directly plotted and examined, as distinct from interpretability, i.e., explaining why a particular fault decision is made.

The main contributions of this work are summarized as follows:

• We propose CTKAN, a hybrid CNN–Transformer–KAN architecture that couples local temporal feature extraction (CNN) with global inter-time-step dependency modeling (Transformer) and a classification head whose per-edge B-spline activation functions can be plotted and inspected individually. The novelty lies in this inspectable-by-construction classification design rather than in maximizing benchmark accuracy.
• Under the reported TE protocol, CTKAN achieves a competitive Macro-F1 of 91.38 ± 0.26% over ten independent training runs among the four main-table architectures, and a factorial ablation quantifies the contribution of the Transformer stage.
• At matched parameter capacity (≈526k), the KAN and MLP classification heads yield comparable Macro-F1 (91.38 ± 0.26% vs. 91.43 ± 0.37%) within seed-to-seed variability; the distinguishing benefit of the KAN head is its directly inspectable B-spline activation curves rather than an accuracy gain.
• Through per-class analyses of hard-to-diagnose TE faults (IDV(3), IDV(9), IDV(15)), we document specific strengths and weaknesses of the model rather than presenting CTKAN as universally superior.

The remainder of this paper is organized as follows. Section 2 reviews related work on deep-learning fault diagnosis and positions CTKAN with respect to existing methods. Section 3 details the proposed CTKAN architecture and its training procedure. Section 4 describes the experimental setup and reports results on the TE benchmark, including ablation, inspectability, and sensitivity analyses. Section 5 discusses the main findings, parameter efficiency, and limitations, and Section 6 concludes the paper.

2. Related Work

This section reviews prior work relevant to the proposed CTKAN framework and positions our contribution. The discussion is organized along four dimensions that are central to inspectable fault diagnosis: (i) local temporal feature extraction, (ii) global temporal dependency modeling, (iii) the transparency of the classification layer, and (iv) evaluation on the TE benchmark. Section 2.1 reviews convolutional and recurrent approaches; Section 2.2 examines Transformer-based and hybrid models; Section 2.3 surveys KAN in fault diagnosis; Section 2.4 discusses the transparency of the classification layer; and Section 2.5 consolidates the comparison in a gap-analysis table and states the research gap that motivates CTKAN.

2.1. Convolutional and Recurrent Approaches

Data-driven fault diagnosis has evolved from classical multivariate statistical methods (such as principal component analysis and its dynamic variants [1,2,10,11]) toward deep-learning models that learn discriminative features directly from raw process data [12]. On the TE benchmark, this transition is well documented: Yin et al. [31] provided a widely used comparison of basic data-driven monitoring methods, and subsequent studies showed that deep models can surpass them; for example, the deep belief network of Zhang and Zhao [32] and the architecture comparison of Chadha and Schwung [33] both demonstrated that learned hierarchical features improve fault classification on TE.

Among deep architectures, convolutional neural networks (CNNs) exploit the local structure of multivariate time series through shared convolutional filters. Wu and Zhao [13] proposed a deep CNN for chemical-process fault diagnosis that learns discriminative features directly from raw signals, and Chen et al. [14] developed a one-dimensional convolutional autoencoder for unsupervised feature learning from multivariate processes. CNNs are computationally efficient and translation-invariant, but standard convolutions with small kernels have an inherently limited receptive field and therefore cannot directly capture dependencies that span distant time steps. Beyond architectural choices, the robustness of CNN-based diagnosers under changing operating conditions has been pursued through transfer learning: Siddique et al. [34] proposed a multistage transfer-learning framework that progressively adapts a pretrained convolutional network to sustain vibration-based fault discrimination across variable rotating-machinery speeds. Such strategies improve cross-condition generalization, but they retain a conventional classification head and target a sensing modality distinct from the multivariate chemical-process signals considered here.

RNNs, in particular LSTM networks [15], instead model temporal sequences through recurrent hidden states and can in principle represent long-range dependencies. Mou et al. [16] applied bidirectional RNNs to TE fault diagnosis and reported improved performance from bidirectional temporal modeling. However, recurrent models process sequences step by step, which precludes parallelization and leads to inefficient training, and they remain susceptible to vanishing-gradient effects on long sequences. Crucially, both CNN- and RNN-based diagnosers in this category retain a conventional MLP classification layer whose decision behavior cannot be inspected directly.

2.2. Transformer-Based and Hybrid Approaches

The Transformer architecture [17] replaces recurrence with self-attention, enabling each time step to attend to all others in parallel and thereby capturing global dependencies efficiently. This property has motivated a series of Transformer-based diagnosers for the TE process. Zhang et al. [18] proposed a generalized Transformer for TE fault diagnosis, and Labbaf-Khaniki et al. [19] introduced a twin Transformer with a gated dynamic learnable attention mechanism that achieved over 94% accuracy. More recent work has enriched the attention backbone with additional structure: Cao et al. [20] augmented a Transformer with a graph attention mechanism for complicated processes, and Zhang et al. [21] proposed a sequence-aware vision Transformer with feature fusion for complex industrial processes. Comparative studies have further mapped the design space: Lomov et al. [35] benchmarked a range of recurrent and convolutional temporal models, including LSTM, GRU, attention-augmented RNNs, and Transformers, on the extended TE dataset, and Kai et al. [23] systematically compared supervised deep-learning algorithms under different temporal subsequence lengths. In a recent deployment-oriented study, Khan et al. [36] combined physics-guided residuals with an attention-based convolutional–recurrent network (Conv1D–BiGRU) for early-warning fault detection on the TE process, coupling strong detection performance with probability calibration and SHAP-based feature attribution.

Hybrid designs combine complementary inductive biases. CNN–LSTM models, such as the optimized network of Chen et al. [22], cascade convolutional feature extraction with recurrent temporal modeling, inheriting both local sensitivity and sequential memory but also the training cost of recurrence. Across these Transformer-based and hybrid approaches, the emphasis is on maximizing predictive accuracy through more expressive encoders, while the classification layer remains a standard linear-plus-softmax head. Attention maps are sometimes presented as a form of explanation, but they describe where the encoder attends rather than how the final classification function transforms the pooled features, and they do not by themselves render the classification layer inspectable.

2.3. Kolmogorov–Arnold Networks in Fault Diagnosis

The Kolmogorov–Arnold representation theorem [27] states that any multivariate continuous function can be expressed as a finite superposition of continuous univariate functions and addition. KAN [26] operationalizes this result by replacing the fixed node activations of an MLP with learnable univariate functions, parameterized as B-splines, placed on the network edges. A direct consequence is that every learned edge function can be plotted and examined, which gives KAN an intrinsic, structural form of transparency at the level of individual connections.

KAN has been adopted across several fault-diagnosis domains. Cabral et al. [28] applied KAN to fault diagnosis of oil-immersed power Transformers; Rigas et al. [29] used KAN for explainable fault classification and severity diagnosis in rotating machinery; Wang et al. [37] combined KAN with hypergraph message passing for rolling-bearing diagnosis in noisy environments; and Morales et al. [30] explored KAN-based autoencoders for unsupervised anomaly detection on the TE process. Livieris [38] showed that integrating convolutional layers with KAN (C-KAN) improves time-series forecasting accuracy, providing evidence that KAN can be productively combined with convolutional front ends. These studies employ KAN for a variety of purposes (improving predictive accuracy [28,37], time-series forecasting [38], unsupervised anomaly detection [30], or explainable severity estimation [29]), but in nearly all of them, KAN serves as the principal predictor, and its functional transparency, when noted at all, is incidental rather than the explicit object of evaluation. Moreover, the KAN is typically used either as a standalone classifier or in combination with a single feature extractor; except for the unsupervised autoencoder of [30], it is rarely deployed as an inspectable classification head on top of a model that jointly captures local and global temporal structure for supervised TE fault classification. In contrast, the present work uses the KAN head specifically as an inspectable classification layer and evaluates whether it can deliver this additional qualitative inspection capability while maintaining predictive performance comparable to a conventional MLP head, a question of head-level inspectability, decoupled from raw accuracy, that prior KAN fault-diagnosis studies have not addressed.

2.4. Transparency of the Classification Layer

Because deep diagnosers are typically opaque, a substantial body of work applies post hoc explainable-AI (XAI) techniques to interpret them. Jang et al. [24] applied explainable AI to fault diagnosis of industrial processes, and Cacao et al. [25] surveyed XAI methods for industrial fault diagnosis; more recently, Khan et al. [36] paired an attention-based CRNN on the TE process with SHAP-guided feature selection and probability calibration to produce operator-facing explanations. Such techniques (for example, SHAP and gradient-based attributions) operate after training on an unchanged, opaque model and produce approximate importance scores for inputs or features. They are valuable but indirect: the classification layer itself remains a black box, and the explanation is an external estimate rather than a property of the model. This motivates a complementary direction, namely making the classification layer structurally inspectable by construction, the role played by the KAN head in the present work, whose learned per-edge activation functions can be plotted directly without any post hoc attribution.

2.5. Comparative Analysis and Research Gap

Table 1. Comparative analysis of representative fault-diagnosis approaches across four key dimensions; the last column summarizes the main gap of each approach.

Method Family	Local Features	Global Dependencies	Inspectable Head	TE Benchmark	Key Limitation
CNN1D/CAE [13,14]	Yes	Limited	No	Yes	Small receptive field misses long-range dependencies; opaque MLP head
RNN/BiLSTM [15,16]	Limited	Yes	No	Yes	Sequential and slow to train, vanishing gradients; opaque head
Transformer [18,19,20,21,39]	Weak	Yes	No	Yes	High accuracy but opaque head; attention is not classification-layer transparency
CNN–LSTM hybrid [22]	Yes	Yes	No	Yes	Combines CNN and RNN but inherits recurrent training cost; opaque head
KAN-based [28,29,30,31,32]	Varies	Usually none	Yes	Rarely	Used in isolation; not combined with a CNN + Transformer encoder for supervised TE classification
CTKAN (this work)	Yes	Yes	Yes	Yes	Unifies local and global encoding with an inspectable KAN classification head

consolidates the preceding discussion along the four dimensions introduced above.

As the table makes explicit, existing approaches each leave at least one dimension unaddressed: CNNs capture local structure but not long-range dependencies; RNNs model sequences but are difficult to train and remain opaque; Transformer-based and hybrid models achieve strong accuracy yet retain opaque classification heads; and KAN-based methods provide an inspectable functional form but have not been integrated with a combined CNN–Transformer encoder for supervised TE fault classification. In short, no prior method simultaneously (i) extracts local features with a CNN, (ii) models global temporal dependencies with a Transformer, and (iii) classifies through an inspectable KAN head, while being evaluated on the standard TE benchmark.

CTKAN is designed to fill precisely this gap. It assigns local and global temporal modeling to a CNN encoder and a Transformer encoder with deliberately complementary, non-overlapping roles, and it replaces the conventional MLP classification head with a KAN head whose B-spline edge activations can be inspected directly. Consistent with our central claim, the contribution of the KAN head is classification-layer inspectability rather than a peak-accuracy gain: as reported in Section 4.3 and Section 4.4, CTKAN attains accuracy comparable to a capacity-matched MLP-head counterpart while additionally providing a directly plottable view of the learned classification-layer transformations.

3. Proposed Method

This section presents the proposed CTKAN framework in detail. We first formalize the fault-diagnosis task (Section 3.1) and outline the overall architecture (Section 3.2). We then describe the three stages in turn—the CNN encoder for local feature extraction (Section 3.3), the Transformer encoder for global dependency modeling (Section 3.4), and the KAN classification head (Section 3.5)—before presenting the training procedure (Section 3.6) and summarizing the complete method as pseudocode (Section 3.7).

3.1. Problem Formulation

Industrial process fault diagnosis is formulated as a supervised multivariate time-series classification problem. A monitored process is characterized by D sensors and manipulated variables sampled over time, and a single diagnostic decision is made on a fixed-length temporal window. Formally, one sample is

X = [x₁, x₂, …, x_T]^⊤ ∈ ℝ^T×D,       x_t ∈ ℝ^D

(1)

where T is the number of time steps contained in the window and x_t is the vector of D process variables observed at time step t. In this study, T = 20 and D = 50. Each window is associated with an operating-condition label

y ∈ Y = {0, 1, …, C − 1},       C = 21

(2)

where y = 0 denotes the normal operating condition and y = 1, …, 20 denote the twenty fault types of the Tennessee Eastman benchmark, giving C = 21 classes in total. Because the process variables differ in physical units and dynamic range, every variable is standardized with the per-variable mean and standard deviation estimated on the training set only; these statistics are then reused unchanged for validation, testing, and online inference:

x̃_t,d = (x_t,d − μ_d)/σ_d,       d = 1, …, D

(3)

where μ_d and σ_d are the training-set mean and standard deviation of the d-th variable, and x̃_t,d is the standardized value. The objective is to learn a parametric mapping f_θ that converts a standardized window X̃ into a posterior distribution over the C classes,

p = f_θ(X̃) ∈ [0, 1]^C,       Σ_c=1^C p_c = 1

(4)

where p_c is the predicted posterior probability of class c and θ collects all trainable parameters. The predicted operating condition is obtained by maximum a posteriori selection:

ŷ = argmax_c ∈ {1,…,C} p_c

(5)

The parameters θ are estimated by minimizing the empirical cross-entropy risk defined in Section 3.6 (Equation (25)).

Beyond this formulation, it is useful to state explicitly the evaluation objectives that the proposed design is intended to satisfy and that the experiments in Section 4 are constructed to test. We organize them as three research questions. (O1) Architectural contribution: How much does the global-dependency-modeling Transformer stage contribute beyond the local features extracted by the CNN encoder? This motivates the factorial ablation in Section 4.3. (O2) Head-level inspectability versus accuracy: Can the KAN classification head, at matched parameter capacity, maintain predictive performance comparable to a conventional MLP head while additionally exposing directly inspectable activation functions? This is the central hypothesis of the paper and motivates both the capacity-matched comparison (Section 4.3) and the inspectability analysis (Section 4.4). (O3) Robustness: How sensitive is the model to its principal hyperparameters, and does training converge under the reported protocol? This motivates the sensitivity and convergence study in Section 4.6. Stating these objectives here links the architectural choices detailed in the following subsections to the specific experimental analyses reported later.

3.2. Overall Architecture

As illustrated in Figure 1, the proposed CTKAN realizes the mapping f_θ as a composition of three sequential stages with complementary roles: a CNN encoder that extracts local temporal features, a Transformer encoder that models global temporal dependencies, and a KAN head that performs inspectable classification. Let d denote the shared hidden dimension (d = 128). In the first stage, the standardized window is mapped to a sequence of local feature vectors,

H_c = E_cnn(X̃; θ_cnn) ∈ ℝ^T×d

(6)

In the second stage, the local features are contextualized by global self-attention while preserving the sequence length,

H_t = E_trans(H_c; θ_trans) ∈ ℝ^T×d

(7)

The contextualized sequence H_t = [h₁, …, h_T], with h_t ∈ ℝ^d its t-th time-step row, is then collapsed into a single window-level descriptor by temporal mean pooling followed by layer normalization,

z = LayerNorm ((1/T) Σ_t=1^T h_t) ∈ ℝ^d

(8)

Finally, the descriptor is mapped to class posteriors by the two-layer KAN head followed by a softmax,

p = softmax (g_kan(z; θ_kan)) ∈ ℝ^C

(9)

so that the full model is the composition f_θ = softmax ∘ g_kan ∘ (LayerNorm ∘ Pool) ∘ E_trans ∘ E_cnn with θ = {θ_cnn, θ_trans, θ_kan}. The three stages are detailed in Section 3.3, Section 3.4 and Section 3.5, the end-to-end training procedure in Section 3.6, and the complete offline training and online inference workflow is summarized as Algorithm 1 in Section 3.7.

3.3. CNN Encoder for Local Feature Extraction

The CNN encoder transforms the raw standardized variables into local temporal feature representations through a stack of L one-dimensional convolutional blocks (L = 2). Treating the standardized window as a multi-channel temporal signal U⁽⁰⁾ = X̃^⊤ ∈ ℝ^D×T, each block applies two convolution–batch-normalization–ReLU operations together with a residual shortcut. For the l-th block, the two convolutional layers are

a^(l) = ReLU (BN (W₁^(L) ∗ u^(l−1) + b₁^(L)))

(10)

and the block output combines the second convolution with a residual connection,

u^(l) = ReLU (BN (W₂^(L) ∗ a^(l) + b₂^(L)) + S^(l) (u^(l−1)))

(11)

where ∗ denotes one-dimensional convolution with kernel size k = 3 and symmetric (non-causal) padding that preserves the sequence length; W and b are learnable kernels and biases; BN is batch normalization; and S^(l) is the identity when the input and output channel counts match and a 1 × 1 convolution otherwise. All blocks use d = 128 output channels, and the encoder output is H_c = (u^(L))^⊤ ∈ ℝ^T×d. With L = 2 blocks and kernel size k, the effective receptive field is

RF = 1 + 2 · L · (k − 1)

(12)

which equals nine time steps for L = 2 and k = 3. This receptive field is deliberately kept smaller than the window length T = 20, so that the CNN encoder captures short-range local patterns while leaving the modeling of longer-range temporal dependencies to the subsequent Transformer encoder. The sensitivity of the diagnosis performance to the kernel size k is analyzed in Section 4.6.

3.4. Transformer Encoder for Global Dependency Modeling

The Transformer encoder [17] models global temporal dependencies among the local features produced by the CNN stage. Because self-attention is permutation-invariant, sinusoidal positional encodings are first added to inject temporal order:

PE_(t,2i) = sin(t/10,000^2i/d),       PE_(t,2i+1) = cos(t/10,000^2i/d)

(13)

Z⁽⁰⁾ = H_c + PE

(14)

where t indexes the time step and i indexes the feature dimension. Each of the N = 2 encoder layers is composed of a multi-head self-attention (MHSA) sublayer and a position-wise feed-forward (FFN) sublayer, each wrapped by a residual connection and layer normalization. For head j, the queries, keys, and values are linear projections of the layer input Z,

Q^(j) = Z W_Q^(j),       K^(j) = Z W_K^(j),       V^(j) = Z W_V^(j)

(15)

and the scaled dot-product attention for that head is

head^(j) = softmax(Q^(j) (K^(j))^⊤/√(d_k)) V^(j)

(16)

where d_k = d/h is the per-head dimension and h = 8 is the number of heads. The head outputs are concatenated and linearly projected,

MHSA(Z) = Concat (head⁽¹⁾, …, head^(h)) W_O

(17)

The attention sublayer output is then formed with a residual connection and layer normalization,

Z′ = LayerNorm (Z + MHSA(Z))

(18)

followed by the position-wise feed-forward sublayer with inner dimension d_ff = 256 and a GELU nonlinearity,

FFN(Z′) = GELU (Z′ W₁ + b₁) W₂ + b₂

(19)

Z″ = LayerNorm (Z′ + FFN(Z′))

(20)

Stacking N = 2 such layers and applying a final layer normalization yields the contextualized sequence H_t used in Equation (7).

3.5. KAN Classification Head

Unlike a conventional MLP head, in which each neuron applies a fixed nonlinearity to a learned linear combination of its inputs, the KAN [26] head places a learnable univariate activation function on every edge. Each such edge function is parameterized as the sum of a SiLU base term and a B-spline expansion,

φ(x) = w_b · SiLU(x) + Σ_i=1^G+s c_i B_i(x)

(21)

where w_b is a learnable scalar weight, SiLU is the sigmoid-weighted linear unit, c_i are learnable spline coefficients, B_i are B-spline basis functions of order s = 3 defined on a uniform grid of size G (G = 5 by default), and the SiLU activation is

SiLU(x) = x · σ(x),       σ(x) = 1/(1 + e^−x)

(22)

A KAN layer that maps an n-dimensional input u to an m-dimensional output sums the edge functions over the input coordinates,

(Φ(u))_q = Σ_p=1ⁿ φ_q,p (u_p),       q = 1, …, m

(23)

where φ_q,p is the learnable activation on the edge connecting input p to output q. The classification head stacks two such layers,

h = Φ₁(z) ∈ ℝ⁶⁴,       o = Φ₂(h) ∈ ℝ^C

(24)

and the logits o are converted to posteriors by the softmax of Equation (9). Because every edge activation φ_q,p is an explicit univariate function, it can be directly plotted and examined after training; this is the inspectability property analyzed in Section 4.4. The influence of the grid size G on both accuracy and the smoothness of the learned activations is studied in Section 4.6.

3.6. Training Procedure

The entire CTKAN model is trained end-to-end by minimizing the multi-class cross-entropy loss over the training set,

L = −(1/N) Σ_n=1^N Σ_c=1^C y_n,c log p_n,c

(25)

where N is the number of training windows, y_n is the one-hot encoding of the label of window n, and p_n is the corresponding predicted posterior. Optimization uses the Adam optimizer [39] with an initial learning rate of 1 × 10⁻³, weight decay 1 × 10⁻⁴, batch size 128, and a budget of 100 epochs. The learning rate follows a cosine-annealing schedule [40],

η_e = η_min + (1/2)(η_max − η_min) (1 + cos(e π/E))

(26)

where e is the current epoch, E = 100 is the total number of epochs, and η_max and η_min are the initial and final learning rates. Gradient norms are clipped to 1.0 for stability. After every epoch, the model is evaluated on the validation set, and the checkpoint achieving the highest validation Macro-F1 is retained as the final model. The convergence behavior of this schedule over the 100-epoch budget is reported in Section 4.6.

3.7. Overall Algorithm

Figure 2 depicts the overall workflow of the proposed CTKAN-based fault diagnosis framework, and Algorithm 1 formalizes the complete pipeline, covering both the offline training stage and the online inference stage. The offline stage estimates the normalization statistics, trains the three-stage network, and selects the best checkpoint, whereas the online stage standardizes each newly acquired process window with the stored statistics, performs inference, and optionally exposes the KAN edge activations for classification-layer auditing before a fault decision is reported.

Algorithm 1. Offline training and online inference of CTKAN

Input: training set Dtr, validation set Dval; epochs E; batch size B; learning-rate bounds (ηmax, ηmin). Output: trained parameters θ* of the CTKAN model. Offline training stage: 1:    Compute per-variable mean μ and standard deviation σ on Dtr 2:    Standardize all windows in Dtr and Dval using Equation (3) 3:    Initialize parameters θ = {θcnn, θtrans, θkan} 4:    for e = 1 to E do 5:            for each mini-batch (X, y) in Dtr do 6:                    Hc ← CNN-Encoder(X)                                  // Equations (10)–(12) 7:                    Ht ← Transformer-Encoder(Hc)              // Equations (13)–(20) 8:                    z      ← LayerNorm(MeanPool(Ht))              // Equation (8) 9:                    p      ← softmax(KAN-Head(z))                      // Equations (9) and (21)–(24) 10:                  L      ← CrossEntropy(p, y)                          // Equation (25) 11:                  Update θ with Adam using the gradient of L 12:          end for 13:          Update the learning rate by cosine annealing    // Equation (26) 14:          Evaluate Macro-F1 on Dval; keep the best θ* so far 15: end for 16: return θ* Online inference stage: 17: Acquire a new process window Xnew and standardize it with stored μ, σ    // Equation (3) 18: p ← fθ*(Xnew)                                                        // Equations (6)–(9) 19: ŷ ← argmaxc pc                                                          // Equation (5) 20: (optional) Plot the KAN edge activations φ for classification-layer auditing    // Equation (21) 21: return predicted fault ŷ and inspection plots

4. Experiments and Results

This section reports the empirical evaluation of CTKAN on the Tennessee Eastman benchmark. Section 4.1 describes the experimental setup, including the dataset, preprocessing, baselines, and implementation details. Section 4.2 presents the main comparison results, Section 4.3 the ablation study, and Section 4.4 the inspectability analysis. Section 4.5 examines hard-to-diagnose faults, and Section 4.6 reports the hyperparameter-sensitivity and convergence analyses.

4.1. Experimental Details

This subsection consolidates the experimental setting: the datasets and their splits (Section 4.1.1), the baselines and CTKAN configuration (Section 4.1.2), and the 2 × 2 factorial ablation design (Section 4.1.3). The training procedure and reproducibility practices (optimizer, schedule, epochs, reproducibility settings, hardware, and metrics) are described in Section 3.6.

4.1.1. Datasets

Table 2. Summary of the TE benchmark used in this study.

Process Variables	Time Steps Per Sample	Number of Classes	Training Samples	Validation Samples	Test Samples
50	20	21 (1 normal + 20 faults)	~104,500	~26,200	~32,700

summarizes the TE benchmark. The TE benchmark [9] simulates a plant-wide chemical process; its 21 operating conditions (one normal + 20 fault scenarios) are recorded over 50 process variables (selected from the 41 measured and 11 manipulated TE variables) with 20 time steps per sample, totaling about 163,400 samples split into 104,500 training, 26,200 validation, and 32,700 test samples using the official train/test partition and a grouped stratified train-only validation split with z-score normalization computed exclusively from training data.

4.1.2. Baselines

Table 3. Configurations of the four end-to-end models compared in this study.

Model	Architecture	Hidden Dim	Other Key Hyperparams	Params
CNN1D	CNN encoder (2 residual blocks) + MLP head	128	kernel = 3, MLP hidden = 128	193,941
RNN (BiLSTM)	Two-layer bidirectional LSTM + linear classifier	64	2 layers, bidirectional	164,117
Transformer	Linear projection + Transformer encoder + linear classifier	64	h = 8 heads, 2 layers, FFN dim = 2d	71,701
CTKAN (Proposed)	CNN encoder + Transformer encoder + 2-layer KAN head	128	h = 8, 2 layers, KAN G = 5, head hidden = 64	526,101

lists the four end-to-end configurations compared in this study. CNN1D reuses CTKAN’s CNN encoder with an MLP head; RNN is a two-layer bidirectional LSTM; the standalone Transformer operates at $d_{model}$ = 64; CTKAN combines the CNN encoder (hidden dimension 128) with a Transformer encoder and the two-layer KAN head (head hidden 64). Each model follows its own standard configuration rather than a single matched-capacity setting, so Table 3 above compares end-to-end architectures as typically deployed.

4.1.3. Ablation Design

To isolate the contributions of the Transformer encoder and the KAN head, we adopt a 2 × 2 factorial ablation: the CNN encoder is always present, while the Transformer stage and the KAN head are each toggled independently. The CNN + Transformer + MLP configuration (denoted “CNN + Trans. + MLP”) directly represents a CNN–Transformer architecture with an MLP classification head, serving as an implicit CNN–Transformer baseline within the ablation design without requiring a separately trained fifth model. This factorial design lets us read the Transformer contribution and the KAN head contribution from the same four cells, rather than from two independent comparisons.

4.2. Main Comparison Results on the TE Dataset

As shown in

Table 4. Comparison of fault diagnosis methods on the TE benchmark (100 epochs). Bold entries denote the proposed CTKAN model.

Model	Params	Accuracy (%)	Macro-F1 (%)	Precision (%)	Recall (%)
CNN1D	193,941	89.89 ± 0.48	90.23 ± 0.47	90.99 ± 0.61	90.11 ± 0.49
RNN (BiLSTM)	164,117	89.14 ± 0.42	89.75 ± 0.42	90.29 ± 0.39	89.42 ± 0.42
Transformer	71,701	90.74 ± 0.28	91.28 ± 0.26	91.76 ± 0.29	90.99 ± 0.25
CTKAN (Proposed)	526,101	90.85 ± 0.20	91.38 ± 0.26	91.97 ± 0.25	91.11 ± 0.21

and Figure 3, the four main-table architectures are directly comparable on Macro-F1 with error bars; CTKAN attains competitive Macro-F1 with comparatively small variability among the four. The standalone CNN1D and RNN (BiLSTM) baselines obtain 90.23 ± 0.47% and 89.75 ± 0.42%, respectively, while the Transformer reaches 91.28 ± 0.26% on a substantially smaller parameter budget (72k vs. CNN1D’s 194k). Stacking a Transformer encoder on the CNN and switching to the inspectable KAN head (CTKAN) yields 91.38 ± 0.26%.

Table 5. Ablation study on the TE benchmark (100 epochs).✓and✗indicate inclusion and exclusion of the Transformer stage and KAN head, respectively. Bold entries denote the proposed CTKAN configuration.

Configuration	Trans.	KAN	Params	Macro-F1 (%)
CNN + MLP (CNN1D)	✗	✗	193,941	90.23 ± 0.47
CNN + KAN	✗	✓	260,885	90.48 ± 0.38
CNN + Trans. + MLP	✓	✗	459,413	91.21 ± 0.32
CNN + Trans. + KAN (CTKAN)	✓	✓	526,101	91.38 ± 0.26

shows that the CNN + Transformer + MLP cell reaches 91.21 ± 0.32%, slightly below CTKAN; the differences among the top three configurations are within seed-to-seed variability over ten runs, so we present CTKAN as a competitive option whose distinguishing feature is classification-layer inspectability rather than as the strongest accuracy configuration. Parameter asymmetry between the MLP and KAN heads is addressed in Section 5.2 with a capacity-matched ablation.

4.3. Ablation Study

Figure 4 visualizes the same ablation, highlighting that the CNN + Transformer configurations cluster slightly above the CNN-only configurations on Macro-F1.

Effect of the Transformer: Models without Transformer (avg F1 ≈ 90.36%) vs. with Transformer (avg F1 ≈ 91.30%) show ~0.94% (about one percentage point) consistent improvement, confirming global attention provides valuable context beyond the CNN’s local receptive field.

Effect of the KAN head: After ten-seed training, the KAN head edges the MLP head in both pairings (without Transformer: 90.48 ± 0.38% vs. 90.23 ± 0.47%; with Transformer: 91.38 ± 0.26% vs. 91.21 ± 0.32%), but in both cases the gap is well within seed-to-seed variability and should be read as comparable performance rather than a clear KAN advantage. The KAN head’s distinguishing benefit on this benchmark is its inherent inspectability through directly plottable B-spline activation curves.

Capacity-matched ablation. Because the CNN + Trans. + KAN configuration (526,101 parameters) and the CNN + Trans. + MLP configuration (459,413 parameters) differ in parameter count, we additionally trained a capacity-matched MLP-head variant (CNN + Trans. + MLP, matched, 526,613 parameters) with the same ten seeds. It reaches 91.43 ± 0.37% Macro-F1, comparable to CTKAN (91.38 ± 0.26%) within seed-to-seed variability. At equal capacity, the MLP head and the KAN head therefore yield comparable Macro-F1 on the TE protocol within seed-to-seed variability; the KAN head’s contribution remains the directly inspectable B-spline activations rather than an accuracy gain.

4.4. Inspectability Analysis

A key motivation for incorporating KAN is classification-layer inspectability. We present three complementary visualization analyses using a representative TE checkpoint. All three analyses operate on learned internal representations rather than raw sensor variables; CTKAN additionally applies post-pooling LayerNorm before feature extraction for t-SNE, which is not used for the other three models.

4.4.1. Feature Space Visualization via t-SNE

Figure 5 shows t-SNE [41] visualizations of the learned feature representations from all four models on the TE test set. Silhouette scores computed on PCA-reduced features do not rank CTKAN first in this checkpoint: CNN1D obtains 0.377, RNN 0.371, Transformer 0.423, and CTKAN 0.271. Therefore, this figure is used as a diagnostic visualization rather than proof that CTKAN has the clearest global feature separation. Note: CTKAN features are extracted after an additional post-pooling LayerNorm that is not applied to the other three models, which may partially account for the observed silhouette difference and means this comparison is not strictly apples-to-apples.

To verify that the small Macro-F1 differences reported above are not artifacts of seed selection, we performed paired significance tests on the ten-seed Macro-F1 distributions, taking CTKAN as the reference. For each competing model, we report the paired t-test p-value, the Wilcoxon signed-rank p-value, and the 95% confidence interval of the paired difference (CTKAN minus the competitor, in percentage points). The results are summarized in

Table 6. Paired significance tests of Macro-F1 against CTKAN over ten independent training runs. ΔMacro-F1 (pp) is the mean paired difference (CTKAN minus competitor) in percentage points; the 95% CI refers to that difference; p-values are from the paired t-test and the Wilcoxon signed-rank test.

Comparison (vs. CTKAN)	ΔMacro-F1 (pp)	95% CI (pp)	Paired t-Test p	Wilcoxon p	Significant (α = 0.05)
CNN1D	+1.15	[0.75, 1.54]	<0.001	0.002	Yes
RNN (BiLSTM)	+1.63	[1.25, 2.01]	<0.001	0.002	Yes
Transformer	+0.10	[−0.14, 0.34]	0.369	0.492	No
CNN + KAN	+0.90	[0.56, 1.25]	<0.001	0.002	Yes
CNN + Trans. + MLP	+0.17	[−0.09, 0.44]	0.171	0.193	No
CNN + Trans. + MLP (matched)	−0.05	[−0.45, 0.35]	0.790	0.770	No

.

Two conclusions follow. First, CTKAN significantly outperforms the CNN1D and RNN baselines and the CNN + KAN configuration without the Transformer stage (all p < 0.001 under both tests), confirming that the Transformer encoder contributes a real improvement rather than seed-level noise. Second, and central to this paper, CTKAN, the standalone Transformer, the CNN + Transformer + MLP ablation, and the capacity-matched MLP head are statistically indistinguishable on Macro-F1 (all p > 0.05 under both tests). In particular, at matched parameter capacity, the KAN and MLP heads differ by only −0.05 pp with a 95% confidence interval of [−0.45, 0.35] pp that comfortably contains zero (paired t-test p = 0.79). This provides direct statistical support for our central claim: the KAN head is not introduced for accuracy gains (at equal capacity, it performs on par with an MLP head), but for the classification-layer inspectability defined in Section 3.4.

4.4.2. Attention Weight Analysis

Figure 6a,b present attention weights from CTKAN’s Transformer (final layer, averaged across heads). The global attention matrix shows approximately uniform attention (expected for T = 20), with subtle temporal biases. Class-averaged vectors reveal fault-specific temporal weighting patterns.

4.4.3. KAN Activation Curve Visualization

Figure 7a,b display the learned B-spline activation functions from the first KAN layer. The response norm plot (7a) shows diversity in learned transformations across 128 input channels. The top 10 most nonlinear channels (7b) exhibit complex S-shaped or peaked responses, while linear channels contribute through simple scaling. This visualization provides classification-layer inspectability unavailable with standard MLP heads. Among the top nonlinear channels in Figure 7b, several indices recur across the reported checkpoint, indicating that the KAN head allocates stronger spline-shaped transformations to a subset of latent dimensions rather than applying a uniform linear map. Unlike an MLP head, whose weight matrices require post hoc attribution to interpret, each KAN edge function can be plotted directly, allowing operators to check whether a latent dimension is saturated, inactive, or threshold-like before classification; this is a qualitative diagnostic view on learned features rather than a claim of higher accuracy. Because these curves operate on pooled latent dimensions rather than on raw sensors, we additionally provide a preliminary Integrated-Gradients attribution that traces the most inspectable latent channels back to the underlying TE process variables (Section 4.7); for each such channel the attribution concentrates on a small group of variables, giving an engineer a concrete, if preliminary, link from an inspectable activation curve to the physical measurements that drive it.

4.5. Analysis of Hard-to-Diagnose Faults

Table 7. Per-class F1 (%, mean ± std) for hard-to-diagnose fault conditions on the TE benchmark. Class k corresponds to fault IDV(k). Best result per row is bold.

Fault Condition	CNN1D	RNN	Transformer	CTKAN	CNN + Trans. + MLP	CNN + KAN
Fault 3/IDV(3) (step change, D feed T)	91.6 ± 0.7	90.4 ± 2.1	94.0 ± 0.9	94.2 ± 1.0	93.6 ± 1.0	91.2 ± 1.4
Fault 9/IDV(9) (random variation, D feed T)	76.2 ± 2.1	75.6 ± 2.5	81.4 ± 1.5	82.5 ± 1.1	81.0 ± 1.0	75.7 ± 1.3
Fault 15/IDV(15) (sticking valve, condenser cooling)	28.4 ± 4.3	38.1 ± 2.2	46.1 ± 1.8	39.4 ± 4.0	36.6 ± 5.9	32.1 ± 4.4

reports per-class F1 for three TE fault conditions known to be challenging across all six architectures. Fault 3 (IDV(3), step change in D feed temperature) is well handled by Transformer-based models: CTKAN (94.2 ± 1.0%), Transformer (94.0 ± 0.9%), and CNN + Trans. + MLP (93.6 ± 1.0%) cluster within roughly one percentage point of each other and are about 2.6 percentage points ahead of CNN1D (91.6 ± 0.7%). Fault 9 (IDV(9), random variation in D feed temperature) is moderately difficult: CTKAN (82.5 ± 1.1%) attains the highest mean among the six, slightly above the standalone Transformer (81.4 ± 1.5%) and CNN + Trans. + MLP (81.0 ± 1.0%). Fault 15 (IDV(15), sticking valve in condenser cooling water) remains the most challenging condition across all models, with F1 ranging from 28.4% (CNN1D) to 46.1% (Transformer). Notably, the standalone Transformer (46.1 ± 1.8%) outperforms CTKAN (39.4 ± 4.0%) on Fault 15, suggesting that pure global attention can be more effective than the hybrid architecture for this fault type. These per-class differences underscore that aggregate Macro-F1 alone does not capture the full picture; model selection for safety-critical deployments should consider class-specific performance on the target fault catalog. Figure 8 plots the same per-class F1 values, making the model-specific differences on Fault 15 visually salient. Figure 9 places the CTKAN class-averaged attention maps for these three faults side by side; the per-class temporal patterns are subtle and should be read as relative tendencies, consistent with the narrow attention range noted for Figure 6a.

To move beyond aggregate scores, we examined the dominant misclassification targets for these faults, aggregated over all ten test runs. Fault 3 is cleanly separated (96.0% recall, 92.5% precision), its only notable leakage being 3.3% of windows assigned to Fault 9. Fault 9 is harder (77.8% recall, 87.7% precision) and spreads across several neighbors, namely Fault 3 (7.3%), Fault 16 (7.1%), Fault 15 (3.7%) and Normal (3.6%), rather than failing on a single competitor. The behavior of Fault 15 is the most informative: 47.2% of its windows are predicted as Fault 16 and a further 11.0% as Normal, leaving only 36.1% correctly recalled. The confusion is bidirectional: Fault 16 is in turn predicted as Fault 15 in 29.4% of its windows and as Normal in 8.4%, so Faults 15 and 16 form a mutually entangled pair that all six architectures, including CTKAN, resolve only partially. This pattern points to a data-level rather than a model-level cause: IDV(15) (a sticking condenser cooling-water valve) and IDV(16) (an unknown disturbance) produce low-amplitude, overlapping signatures whose inter-class separation within a 20-step window is small, and both also drift toward the Normal operating region. Consistent with this interpretation, the same hard faults remain difficult across every architecture in our study and across the TE benchmark literature reviewed in Section 2, indicating an intrinsic limitation of the windowed representation rather than a deficiency specific to the KAN head. Addressing these classes would therefore require longer observation windows and feature engineering targeted at low signal-to-noise fault conditions, which we identify as a concrete direction for future work.

4.6. Hyperparameter-Sensitivity and Convergence Analysis

To address concerns regarding the sufficiency of the training budget and the robustness of our hyperparameter choices, this subsection reports three additional analyses conducted under the protocol of Section 4.1: the convergence behavior over the 100-epoch budget, the sensitivity of CTKAN to the KAN B-spline grid size, and its sensitivity to the CNN encoder kernel size. All results are reported as mean ± standard deviation over the same ten random seeds used throughout.

Training convergence. Figure 10 presents the learning curves over the 100-epoch budget. Panel (a) plots CTKAN’s training and validation cross-entropy loss (mean ± standard deviation across the ten seeds); both decrease smoothly and plateau after roughly 40 epochs, with the validation loss closely tracking the training loss and showing no sign of divergence or overfitting. Panel (b) shows that the validation loss of all four main-table architectures stabilizes well before epoch 100. Together, these curves confirm that the 100-epoch budget is sufficient for the 526k-parameter CTKAN model to converge.

B-spline grid size. The grid size G controls the resolution of the learnable B-spline activations in the KAN head.

Table 8. Sensitivity of CTKAN to the KAN B-spline grid size G on the TE benchmark (mean ± std over ten independent training runs). ΔMacro-F1, the 95% confidence interval, and the p-value are computed against the default G = 5 using paired tests; ‘—’ marks the reference configuration.

Grid Size G	Params	Macro-F1 (%)	ΔMacro-F1 (pp)	95% CI (pp)	Paired t-Test p
3	507,029	91.45 ± 0.30	+0.07	[−0.21, +0.35]	0.580
5 (default)	526,101	91.38 ± 0.26	—	—	—
7	545,173	91.37 ± 0.41	−0.01	[−0.37, +0.36]	0.972
10	573,781	91.39 ± 0.25	+0.01	[−0.17, +0.19]	0.911

reports CTKAN performance for G ∈ {3, 5, 7, 10} with all other settings held fixed. Macro-F1 remains within 91.37–91.45% across the entire range, and none of the differences relative to the default G = 5 are statistically significant (paired t-test p ≥ 0.58). Increasing G enlarges the parameter count (from 507k to 574k) without any measurable accuracy gain, confirming that G = 5 is a sound and parsimonious default. Figure 11 further illustrates how the grid size affects the inspectability of the learned activation curves: for a coarse grid, the activations are smooth and near-monotonic, whereas finer grids produce increasingly oscillatory curves. Quantitatively, the mean absolute curvature of the learned activations rises from 0.04 at G = 3 to 0.26 at G = 7 and 0.56 at G = 10. Finer grids therefore yield fewer inspectable activations while providing no accuracy benefit, which reinforces the choice of a moderate grid size.

CNN kernel size. The CNN encoder uses a kernel size of 3, giving an effective receptive field of approximately 9 time steps, or about 45% of the 20-step window (Section 3.2).

Table 9. Sensitivity of CTKAN to the CNN encoder kernel size on the TE benchmark (mean ± std over ten independent training runs). Statistics are computed against the default kernel size of 3; ‘—’ marks the reference configuration.

Kernel Size	Params	Macro-F1 (%)	ΔMacro-F1 (pp)	95% CI (pp)	Paired t-Test p
3 (default)	526,101	91.38 ± 0.26	—	—	—
5	637,205	91.43 ± 0.37	+0.05	[−0.29, +0.39]	0.732
7	748,309	91.16 ± 0.29	−0.22	[−0.47, +0.03]	0.076

reports performance for kernel sizes {3, 5, 7}. Kernel sizes 3 and 5 perform comparably (91.38% versus 91.43%, p = 0.73), whereas kernel size 7 yields a slight and non-significant decrease (−0.22 pp, p = 0.076) at a substantially higher parameter cost (from 526k to 748k). The default kernel size of 3 thus offers the best accuracy–parsimony trade-off and preserves the intended division of labor in which the CNN captures local patterns while the Transformer models global dependencies.

4.7. Linking Inspectable Latent Dimensions to Process Variables

The inspectability analysis in Section 4.4 operates on the pooled latent vector that the KAN head receives, not on the raw process variables. To make the directly plottable activation curves actionable for process engineers, we trace the most inspectable latent dimensions back to the original TE measurements with a post hoc Integrated-Gradients (IG) attribution. For the eight most nonlinear KAN-head input channels (the dimensions highlighted in Figure 7b), we attribute each latent value to every element of the 20-step × 50-variable input using a zero baseline (the per-feature training mean, since the inputs are train-only z-scored) and 32 integration steps, sum the signed attributions over the time axis, and average their magnitudes over 2000 randomly drawn test windows. A representative CTKAN model (seed 43) trained under the standard protocol is used; full details are given with the released code.

Figure 12 shows the resulting attribution map, and

Table 10. The most influential TE process variables for the inspectable latent subspace: mean normalized Integrated-Gradients attribution (averaged over the eight inspectable channels of Figure 12) and the number of those channels in whose top-five contributors the variable appears.

Process Variable	Mean Attribution (%)	In Top 5 (of 8 Channels)
v21	21.3	8
v49	6.0	8
v22	4.6	6
v18	3.8	6
v11	3.4	4
v42	3.1	3
v10	2.9	1
v48	2.8	1
v1	2.6	3

summarizes the variables that most strongly drive these channels. Two observations stand out. First, the attribution of every inspectable channel concentrates on a small subset of the 50 variables rather than spreading uniformly, confirming that each directly plottable activation curve can be associated with a compact group of physical measurements. Second, one variable (index 21) dominates the inspectable latent subspace, contributing 21.3% of the averaged attribution, followed by variables 49, 22, 18 and 11. For a process engineer this provides a concrete, if preliminary, reading of the model: it identifies which sensors a given inspectable curve responds to, allows the model’s internal logic to be cross-checked against process knowledge, makes it possible to flag cases where the dominant variables are physically implausible for a declared fault, and helps recognize when activations drift into regions not seen during training, an early indication of an unfamiliar operating condition. We emphasize that this attribution captures statistical dependence rather than a causal physical explanation of fault mechanisms; a complete causal account and a quantitative human-factors evaluation (for example, operator-in-the-loop studies and time-to-diagnosis measurements) remain directions for future work, as discussed in Section 5.3.

5. Discussion

This section interprets the experimental findings and discusses their implications. Section 5.1 analyzes the main results, Section 5.2 examines parameter efficiency, and Section 5.3 discusses the limitations of the present study.

5.1. Analysis of Main Results

CTKAN achieves a Macro-F1 of 91.38 ± 0.26% over ten independent training runs, competitive among the four main-table architectures in Table 4. The CNN + Transformer + MLP ablation reaches 91.21 ± 0.32% (459k parameters); a capacity-matched MLP-head variant (526k parameters) reaches 91.43 ± 0.37%. At matched capacity, the MLP and KAN classification heads therefore yield comparable Macro-F1 within seed-to-seed variability, confirming that the KAN head’s primary contribution on this benchmark is classification-layer inspectability (direct visualization of learned B-spline functions) rather than an accuracy gain. The Transformer stage contributes about 0.94 percentage points to Macro-F1 over CNN-only baselines (90.36% average without Transformer vs. 91.30% with). Several published TE studies report 97–99% accuracy under different windowing, partitioning, or feature-construction protocols; although those figures are higher than ours, the present work targets hybrid architecture design with component-level ablation and directly inspectable KAN activations on the TE protocol used here. Under that setting, 91.38% Macro-F1 over ten seeds is a strong, reproducible result, and the main contribution is the inspectable CNN–Transformer–KAN design rather than matching every published accuracy ceiling.

5.2. Parameter Efficiency

CTKAN’s 526k parameters are notably higher than several baselines, most visibly the standalone Transformer (72K), reflecting the Transformer encoder operating at the CNN’s hidden dimension (128) together with the KAN’s B-spline coefficients. This naturally raises the question, rightly highlighted in the review, of whether CTKAN’s behavior stems from its architecture or merely from a larger parameter budget. Our experimental design controls for this directly. The factorial ablation in Section 4.3 isolates each component at comparable scale, and the capacity-matched control equips the MLP-head variant with essentially the same parameter budget as CTKAN (≈526k). Under these controls, the Transformer stage delivers a Macro-F1 gain over CNN-only variants (Section 4.3) that the paired significance tests confirm are statistically significant (Section 4.4.1, Table 6), whereas the KAN and MLP heads perform comparably within seed-to-seed variability at matched capacity. Neither conclusion therefore rests on a parameter-count advantage: the Transformer’s contribution is a genuine architectural effect rather than a capacity artifact, and the KAN head’s distinguishing value is classification-layer inspectability rather than additional accuracy purchased with parameters. While the absolute parameter count is modest by modern standards, parameter efficiency could be improved further through knowledge distillation or shared attention mechanisms.

5.3. Limitations

Statistical variability. Results are aggregated over ten independent training runs; performance differences within roughly half a percentage point of Macro-F1 should be interpreted as indicative trends rather than statistically confirmed gains.

Inspectability versus interpretability. The KAN head provides a useful internal visualization of the transformations learned at the classification layer, but this should not be read as a causal explanation of physical fault mechanisms. Because the spline curves act on pooled latent features rather than on the original process variables, we performed a preliminary post hoc attribution that uses Integrated Gradients to link the most inspectable latent dimensions back to the raw TE process variables; as reported in Section 4.7 (Figure 12 and Table 10), the attribution for each inspectable channel concentrates on a small subset of process variables, demonstrating that such latent-to-sensor tracing is achievable for the proposed framework. A complete causal account connecting spline activations to physical fault mechanisms, together with a quantitative evaluation of how the attention and t-SNE visualizations relate to predictive performance, for example, through perturbation-consistency or attention-rollout analyses, remains beyond the present scope and is left for future work. Finally, the practical value of classification-layer inspection should ultimately be assessed under realistic operating conditions, for instance through operator-in-the-loop studies, measurements of time-to-diagnosis, and head-to-head comparison with established explainability tools such as Integrated Gradients and SHAP.

Window length. Our experiments adopt the standard 20-step TE windowing to preserve comparability with prior work [9,23]. Each window is classified independently, and at deployment, the diagnoser is applied continuously on a sliding-window basis, so the model is not required to observe an entire fault evolution (which may span hundreds of time steps) within a single sample. Moreover, although self-attention over 20 positions produces near-uniform attention maps, the Transformer stage still yields a measurable Macro-F1 gain over CNN-only variants (Section 4.3). A systematic study of longer observation windows, which would require re-simulating the raw continuous process streams, is left for future work.

Single-benchmark scope. All experiments in this study were conducted on the Tennessee Eastman process. Although TE is the most widely adopted benchmark for chemical-process fault diagnosis and spans twenty diverse fault types, it remains a single simulated process; the generalizability of CTKAN, and of the inspectability behavior reported here, to other industrial processes, to real plant data with unmodelled noise and operating-point drift, and to different sensor suites has therefore not yet been demonstrated. The quantitative findings above should accordingly be read as specific to this benchmark and evaluation protocol rather than as evidence of general applicability. External validation across additional industrial process datasets is necessary before broader conclusions can be drawn, and we regard this as the primary direction for future work.

6. Conclusions

This paper proposed CTKAN, a three-stage hybrid architecture for industrial process fault diagnosis, integrating a CNN1D encoder, a Transformer encoder, and a KAN-based classification head with directly inspectable edge functions. Under the reported TE protocol, CTKAN obtains a competitive Macro-F1 of 91.38 ± 0.26% over ten independent training runs, comparable to the CNN + Transformer + MLP ablation (91.21 ± 0.32%) and to a capacity-matched MLP-head variant (91.43 ± 0.37%) within seed-to-seed variability; at matched capacity, the two heads perform comparably, so the KAN head’s distinguishing benefit on TE is classification-layer inspectability rather than peak accuracy. These results directly answer the research question posed in the Introduction: a KAN-based classification head can provide a directly inspectable view of the classification layer in industrial fault diagnosis without sacrificing predictive performance relative to a conventional MLP head, since the two heads attain comparable Macro-F1 at matched parameter capacity. The contribution of CTKAN is therefore not a new accuracy ceiling on the TE benchmark but a hybrid architecture whose classification layer is inspectable by construction. In practical terms, this inspectability can support industrial fault-diagnosis workflows in two ways. First, the plottable per-edge B-spline activations serve as a model-audit tool, allowing process engineers to verify before deployment that the classification layer relies on smooth, physically plausible nonlinear responses rather than erratic artifacts. Second, when combined with sensor-level attribution, as demonstrated by the Integrated-Gradients analysis in Section 4.7, the inspectable curves can be traced back to the process variables that drive each latent dimension, giving operators a concrete starting point for relating model behavior to specific measurements during fault attribution. Two priorities stand out for future work. First, because all experiments here were conducted on the single Tennessee Eastman benchmark, validation across additional industrial process datasets, including real plant data with unmodelled noise and operating-point drift, is necessary before broader conclusions about the general applicability of CTKAN can be drawn. In this direction, transfer-learning strategies such as the multistage adaptation of Siddique et al. [34] offer a promising route to port CTKAN across operating conditions and processes with limited labeled data. Second, the inspectable KAN latent-feature curves should be connected to raw process variables through sensor-level attribution methods (e.g., Integrated Gradients or SHAP), building on the preliminary analysis in Section 4.7.