Missed-attack-risk-oriented compact KAN architecture for industrial IoT intrusion detection

1 Introduction

Industrial Internet of Things (IIoT) environments connect sensors, controllers, machines, gateways, and enterprise systems to support automation, predictive maintenance, real-time monitoring, and data-driven industrial decision-making. These deployments improve operational efficiency, but they also expand the cyberattack surface across cyber-physical processes, device communication, and edge-level monitoring points (Sisinni et al., 2018; Boyes et al., 2018; Chataut et al., 2023; Kamm et al., 2023). In such environments, intrusion detection systems (IDSs) must do more than achieve high benchmark accuracy. They must support reliable detection under class imbalance, attack ambiguity, latency constraints, and resource limitations.

A central challenge in IIoT intrusion detection is that classification errors are operationally asymmetric. False positives increase analyst workload and may contribute to alert fatigue, but false negatives correspond to missed malicious activity. In safety- and operation-sensitive industrial environments, undetected attack traffic can remain active inside monitored networks and delay containment or response. This makes false-negative behavior especially important for IDS evaluation. Prior work on intrusion detection measurement and cyber-physical IDS has emphasized that operational usefulness depends on realistic error trade-offs, detection behavior, and attack consequences rather than headline accuracy alone (Axelsson, 2000; Mitchell and Chen, 2014; Umer et al., 2022).

This problem is amplified by class imbalance and label granularity. IIoT datasets often contain dominant benign traffic or frequent attack categories alongside smaller or more ambiguous attack classes. A model can therefore report strong overall performance while still missing operationally important attacks. Imbalanced-learning studies have long shown that aggregate metrics may obscure minority-class behavior (He and Garcia, 2009), and IDS benchmark analyses have similarly warned that dataset properties can inflate apparent performance or hide weak class-specific detection (Tavallaee et al., 2009). Moreover, attack families such as denial-of-service (DoS), distributed denial-of-service (DDoS), brute-force activity, reconnaissance, and web-based attacks may not be equally separable. Fine-grained label settings can expose difficult decision boundaries that are hidden when related attack types are merged.

Recent deep learning-based IDS models, including convolutional neural networks, recurrent networks, attention-based models, and hybrid architectures, have achieved strong detection results across IoT and IIoT benchmarks (Soliman et al., 2023; El-Ghamry et al., 2023; Wang and Ghaleb, 2023; Kasongo, 2023; Momand et al., 2024; Al Qathrady et al., 2024). Several studies have also addressed class imbalance through focal loss, resampling, cost-sensitive training, or rare-attack-aware optimization (Peng et al., 2023; Miryahyaei et al., 2024; Zhang et al., 2024). These approaches are important, but many of them treat false-negative reduction primarily as a training strategy or reporting metric. Less attention has been given to false-negative-aware architectural design, where feature transformation, feature refinement, component ablation, and deployment cost are evaluated together as part of a missed-attack-risk problem.

Compact and deployment-oriented IDS design is also important for IIoT because monitoring may occur at gateways, edge servers, or constrained industrial devices. Lightweight IDS studies have shown the value of efficient learning, reduced feature sets, and deployment-aware evaluation across IoT and IIoT settings (Meidan et al., 2018; Ismail et al., 2025; Peng et al., 2025). However, compactness alone is not sufficient. A model that is small or fast but leaves more attacks missed may be unsuitable for safety- and operation-sensitive monitoring. Conversely, a model that reduces missed detections but becomes too expensive may be difficult to deploy. This creates a practical need for IDS designs that jointly evaluate missed-attack reduction, operational error decomposition, and computational feasibility.

Kolmogorov–Arnold Networks (KANs) provide a promising direction for compact intrusion detection because they replace fixed node-based nonlinearities with learnable functional transformations (Liu et al., 2025). Recent KAN and convolutional KAN variants have shown competitive performance in intrusion detection and related security tasks while maintaining compact model footprints (Elaziz et al., 2024; Rizk et al., 2025; Wang et al., 2025). However, much of the current KAN-based IDS literature remains centered on overall predictive performance, architectural novelty, or parameter efficiency. Less attention has been given to whether compact KAN-centered designs can be organized and evaluated around missed-attack risk: reducing false negatives, decomposing residual errors into operationally meaningful categories, testing component-level contributions, and interpreting the deployment cost of risk reduction.

This paper addresses that gap by studying false-negative-aware IIoT intrusion detection through a compact KAN-centered architecture called CKAN-AFG, short for Convolutional KAN with Attention and Feature Gating. CKAN-AFG combines KAN-based nonlinear feature transformation, residual multi-head feature attention, channel-wise feature gating, adaptive pooling, and a compact KANLinear classification head. The model is intentionally non-recurrent and deployment-conscious. Rather than increasing hybrid recurrent modeling capacity, it allocates limited representational capacity to compact feature transformation, residual feature refinement, and channel recalibration.

This distinction is important because our earlier CKAN–BiLSTM study introduced a hybrid KAN-based IDS that combined CKAN feature extraction, BiLSTM-based recurrent processing, and attention for efficient IIoT intrusion detection on TON-IoT (Elwhishi et al., 2026). The present work has a different objective. CKAN–BiLSTM is treated as a continuity baseline, not as the framing of the contribution. The new study asks whether a compact, non-recurrent KAN-centered design can reduce false-negative behavior, where residual missed detections remain, and what deployment trade-off is paid for that reduction. The contribution is therefore not simply another KAN layer or another high-accuracy IDS model; it is a missed-attack-risk-oriented analysis of compact KAN feature refinement in IIoT intrusion detection.

The experimental evaluation uses the CIC IIoT Dataset 2025, also referred to as DataSense, as the main benchmark (Firouzi et al., 2025; Canadian Institute for Cybersecurity, 2025), and TON-IoT as a secondary IIoT benchmark for cross-dataset comparison and continuity with prior IIoT IDS evaluation (Alsaedi et al., 2020). The evaluation emphasizes false-negative rate (FNR), false-positive rate (FPR), support-weighted performance metrics, balanced accuracy, operational error decomposition, class-level error structure, ablation behavior, and deployment-oriented efficiency measures. This design allows the study to answer five practical questions: whether CKAN-AFG reduces true missed attacks, where residual error remains, which architectural components contribute to FNR reduction, what efficiency cost is paid, and whether the behavior remains consistent beyond the main benchmark.

The results show that CKAN-AFG achieves a weighted F1-score of 99.8146% and an FNR of 0.2636% on DataSense under the final leakage-controlled 55-common-feature protocol, corresponding to an approximately 5.6% relative FNR reduction compared with the CKAN–BiLSTM continuity baseline. The operational error decomposition shows that CKAN-AFG produces the lowest attack-to-benign count, with 33.8 mean true missed attacks, and the lowest total off-diagonal error count among the retained models. The KAN-isolation and component-ablation study further shows that replacing KAN-specific components with CNN or LSTM alternatives, or removing attention and feature gating, degrades the false-negative-aware profile. From a deployment-oriented perspective, CKAN-AFG remains compact, with 247,005 trainable parameters, a 0.956 MB FP32 footprint, and CPU-only throughput of approximately 1,691 samples/s.

The main contributions of this study are summarized as follows:

• We frame IIoT intrusion detection as a missed-attack-risk problem and evaluate IDS behavior using FNR, FPR, operational error decomposition, repeated-seed stability, and deployment-oriented cost rather than relying only on aggregate accuracy.
• We introduce CKAN-AFG, a compact non-recurrent KAN-centered IDS architecture that combines KAN-based feature transformation, residual multi-head feature attention, feature gating, adaptive pooling, and a KANLinear classifier to support missed-attack-risk-oriented IIoT detection.
• We provide an integrated empirical analysis across DataSense and TON-IoT, including leakage-controlled fold-confined feature selection, KAN-isolation and component-level ablation, operational error decomposition, repeated-seed stability, and CPU-based deployment-efficiency profiling.

The rest of the paper is organized as follows. Section 2 reviews the background and related work on IIoT IDS, class imbalance, compact models, and KAN-based intrusion detection. Section 3 presents the materials and methods, including the datasets, preprocessing pipeline, leakage-controlled evaluation protocol, CKAN-AFG architecture, comparison models, ablation design, evaluation metrics, and implementation details. Section 4 reports the results through six guiding analyses: missed-attack reduction, operational error decomposition, component contribution, deployment trade-off, cross-dataset behavior, and repeated-seed stability. Section 5 discusses the interpretation of the results, practical implications, threats to validity, and future work. Section 6 concludes the paper.

2 Background and related work

This section summarizes the research context needed to position CKAN-AFG. The goal is not to provide a broad tutorial on IIoT security, KANs, or deep learning, but to identify the specific gap addressed in this study: compact IIoT intrusion detection evaluated through missed-attack risk, operational error decomposition, KAN-isolation and component ablation, repeated-seed stability, and deployment-oriented cost.

2.1 IIoT intrusion detection and error asymmetry

IIoT environments differ from conventional enterprise networks because they combine cyber-physical processes, heterogeneous devices, industrial communication, and latency-sensitive monitoring requirements. IDSs in these environments must therefore balance detection performance with operational constraints such as limited compute, real-time monitoring, device heterogeneity, and deployment feasibility (Sisinni et al., 2018; Boyes et al., 2018; Soliman et al., 2023; Umer et al., 2022). This makes IIoT intrusion detection a practical security problem rather than a purely predictive classification task.

A key issue is the asymmetric impact of detection errors. False positives increase analyst workload and may contribute to alert fatigue, but false negatives represent missed malicious activity. In industrial and cyber-physical environments, undetected attack traffic may delay response while adversarial activity continues to affect connected devices, control logic, or operational processes. Classic intrusion detection measurement work and cyber-physical IDS surveys emphasize that detector usefulness depends on realistic error trade-offs, base rates, detection latency, and operational consequences rather than headline accuracy alone (Axelsson, 2000; Mitchell and Chen, 2014). This motivates evaluation that treats false-negative behavior as a primary concern.

Class imbalance further complicates IIoT IDS evaluation. Many IDS datasets contain large benign classes or dominant attack families, while rare or ambiguous attacks appear less frequently. Under these conditions, models may report high accuracy while still missing minority attack classes. Imbalanced-learning research has shown that aggregate performance can obscure minority-class behavior (He and Garcia, 2009), and IDS benchmark analyses have similarly shown that dataset design and class distribution can inflate apparent performance (Tavallaee et al., 2009). For IIoT IDS, this means that balanced accuracy, false-negative rate (FNR), operational error decomposition, and class-level error structure are needed alongside support-weighted aggregate metrics to understand where residual security risk remains.

2.2 Deep learning, imbalance-aware IDS, and compact deployment

Deep learning-based IDS approaches have achieved strong performance using convolutional, recurrent, attention-based, and hybrid architectures. CNN-based models are commonly used for local feature extraction, recurrent networks such as LSTM and BiLSTM capture sequential dependencies, and attention mechanisms help emphasize informative representations (El-Ghamry et al., 2023; Wang and Ghaleb, 2023; Kasongo, 2023; Momand et al., 2024; Al Qathrady et al., 2024). Hybrid models can improve detection performance, but the added depth and architectural complexity may increase memory use, latency, and training cost.

Several studies have addressed imbalance using focal loss, resampling, cost-sensitive training, or rare-attack-aware objectives. For example, CNN-BiLSTM models with focal loss have been proposed to improve detection under imbalanced network intrusion settings (Peng et al., 2023), while temporal convolutional and Transformer-based methods have also been used to improve rare or long-tail attack detection (Miryahyaei et al., 2024; Zhang et al., 2024). These studies are important because they recognize that aggregate accuracy is insufficient. However, much of this literature treats false-negative reduction primarily as a training objective or metric-level issue. Less attention has been given to architectures whose components are explicitly evaluated for their contribution to missed-attack reduction.

In parallel, compact and deployment-oriented IDS has become an important research direction. Edge and gateway monitoring points may not support large models or expensive inference pipelines, especially under high-throughput IIoT traffic. Lightweight IDS studies have examined efficient learning, reduced feature sets, and deployment-aware evaluation across IoT and IIoT benchmarks (Meidan et al., 2018; Ismail et al., 2025; Peng et al., 2025). These studies show that compactness matters, but compactness alone is not enough. A small model that leaves more attacks missed may be unsuitable for safety-sensitive monitoring, while a highly accurate model that is too computationally expensive may be impractical. The relevant question is therefore not only whether an IDS is accurate or lightweight, but whether it provides a defensible trade-off between missed-attack reduction and deployment cost.

2.3 KAN-based intrusion detection

Kolmogorov–Arnold Networks (KANs) have recently emerged as an alternative neural architecture based on learnable functional transformations rather than fixed node-based nonlinearities (Liu et al., 2025). This design is attractive for intrusion detection because IIoT traffic features often contain nonlinear relationships among protocol behavior, device activity, timing, and attack indicators. A compact KAN-centered model may capture such relationships without relying on increasingly deep or parameter-heavy architectures.

Recent IDS research has begun exploring KAN and convolutional KAN variants. CKAN was proposed for intrusion detection in IoT environments and showed that convolutional KAN-style representations can provide competitive accuracy with compact model behavior (Elaziz et al., 2024). KAN-MID further explored KAN-based modeling for malicious URL and intrusion detection in IoT systems (Rizk et al., 2025), while other CKAN-based IDS work has examined the use of convolutional KAN models for accurate and interpretable intrusion detection (Wang et al., 2025). These studies establish KANs as a promising direction for security analytics.

Our earlier CKAN–BiLSTM work extended this line of research by combining CKAN feature extraction, BiLSTM-based recurrent processing, and attention-based feature prioritization for efficient IIoT intrusion detection on TON-IoT (Elwhishi et al., 2026). The present work is intentionally different. Instead of increasing recurrent or hybrid modeling capacity, CKAN-AFG investigates whether a compact, non-recurrent KAN-centered architecture can reduce false-negative behavior through feature refinement and recalibration. In this paper, CKAN–BiLSTM is therefore used as a continuity baseline rather than as the conceptual frame of the contribution.

2.4 Research gap and positioning of this study

The reviewed literature shows clear progress, but three gaps remain. First, false-negative reduction is often treated as a secondary metric, a loss-function issue, or an imbalance-handling strategy, rather than as a central design and evaluation objective. Second, compact IDS studies often emphasize speed, parameter count, or general accuracy without decomposing residual errors into operationally different categories such as true missed attacks, attack-family misclassifications, and false alarms. Third, KAN-based IDS research has demonstrated promising accuracy and efficiency, but has not sufficiently examined compact KAN-centered design through the combined lens of missed-attack risk, operational error decomposition, KAN-isolation and component ablation, cross-dataset behavior, repeated-seed stability, and deployment-oriented cost.

This study is positioned at the intersection of these gaps. CKAN-AFG is not presented as a generic high-accuracy IDS model or as a simple accumulation of KAN, attention, and gating modules. Instead, it is evaluated as a compact KAN-centered design for missed-attack-risk-oriented IIoT intrusion detection. The study asks whether CKAN-AFG reduces true missed attacks, how residual multiclass errors decompose operationally, which components contribute to FNR reduction, what computational cost is paid, and whether the observed behavior remains consistent beyond the main benchmark.

To make this positioning explicit, Table 1 summarizes representative recent IDS directions and the gap addressed by this work. Representative studies for each research direction are cited in the preceding subsections; Table 1 summarizes the resulting positioning of CKAN-AFG relative to these directions.

Table 1. Positioning of CKAN-AFG relative to representative IDS research directions.

3 Materials and methods

This section describes the datasets, preprocessing pipeline, evaluation protocol, CKAN-AFG architecture, comparison models, ablation design, evaluation metrics, and implementation details. The goal is to provide enough methodological detail for reproducibility while keeping the manuscript focused on the central question: whether compact KAN-centered feature refinement can reduce missed-attack behavior in IIoT intrusion detection under deployment-oriented constraints.

3.1 Study design

The study follows a comparative experimental design. The CIC IIoT Dataset 2025, also referred to as DataSense, is used as the primary benchmark because it provides a recent IIoT-focused evaluation setting with heterogeneous devices, synchronized sensor and network data, and diverse attack categories (Firouzi et al., 2025; Canadian Institute for Cybersecurity, 2025). TON-IoT is used as a secondary benchmark to support cross-dataset comparison and continuity with prior IIoT IDS evaluation (Alsaedi et al., 2020).

The main evaluation asks five primary questions: whether CKAN-AFG reduces true missed attacks, where residual error remains, which architectural components contribute to false-negative reduction, what computational cost is paid for the reduction, and whether the observed behavior remains consistent beyond the main benchmark. A repeated-seed stability analysis examines whether the primary DataSense findings remain consistent across the controlled seed-level summaries.

3.2 Datasets and task formulation

3.2.1 CIC IIoT Dataset 2025 (DataSense)

DataSense is used as the main benchmark in this study. The retained DataSense configuration contains 547,468 samples after preprocessing, duplicate removal, feature filtering, and label harmonization. The final preprocessed matrix contained 102 candidate input features before supervised feature selection, excluding the target label.

The main task is formulated as an eight-class classification problem under the DoS/DDoS-separate setting. The retained classes are Benign, Bruteforce, DDoS, DoS, Malware, MITM, Recon, and Web. The final class distribution is as follows: Benign: 278,357; Recon: 96,683; DoS: 56,494; DDoS: 54,191; MITM: 24,493; Malware: 23,675; Web: 8,226; and Bruteforce: 5,349. This setting preserves fine-grained attack-family ambiguity, especially between related availability-oriented attacks, and is therefore suitable for evaluating missed-attack behavior.

The evaluation protocol uses fold-confined Random-Forest-based Recursive Feature Elimination (RF-RFE) (Guyon et al., 2002) rather than global feature selection. RF-RFE was fitted only on the corresponding fold-training subset and never on the fold-validation subset or the independent test set. Each RF-RFE run selected 60 features. Across the three controlled seeds and ten folds per seed, RF-RFE was executed 30 times in total. A set of 55 features was selected consistently in all 30 RF-RFE runs and was retained for the final common-feature evaluation. Thus, the final reported DataSense comparison uses a leakage-controlled 55-common-feature protocol.

To make the split construction transparent, Table 2 reports the full DataSense class distribution together with the one-time stratified 80/20 split used to create the training/validation pool and the independent test set.

Table 2. DataSense class distribution after preprocessing and the one-time 80/20 stratified split used in the evaluation protocol.

The training/validation pool was used for seed-specific 10-fold train/validation splitting, while the independent test set was held out from feature selection, scaling, model fitting, early stopping, and hyperparameter selection.

The DoS/DDoS-separate setting is used as the primary evaluation protocol because merging related availability-oriented attacks can hide fine-grained attack-family ambiguity and obscure whether residual errors correspond to true missed attacks or attack-family misclassifications.

3.2.2 TON-IoT

TON-IoT is used as a secondary IIoT benchmark. It provides telemetry from seven heterogeneous device subsets—Fridge, Garage Door, GPS Tracker, Modbus, Motion Light, Thermostat, and Weather—and includes benign and malicious activity across multiple attack scenarios (Alsaedi et al., 2020). In this study, TON-IoT serves two purposes. First, it provides continuity with the earlier CKAN–BiLSTM IIoT IDS study (Elwhishi et al., 2026). Second, it allows CKAN-AFG behavior to be compared beyond the main DataSense benchmark.

Each device subset was represented as an ordinary two-dimensional tabular matrix containing one independent record per row and 8–15 input features per record. No sliding-window construction or multi-record input sequence was used. Six retained variables were derived from timestamps and therefore supplied within-record temporal context, but the models were not given histories of preceding records. For every device, a fixed seed of 1 was used to form an approximately stratified 80/20 training/validation-pool and independent-test split. Stratified 10-fold train/validation splitting was then conducted within the training/validation pool. Every model was independently initialized and retrained for every device and fold using the same device records, partitions, preprocessing, and batch size of 2,056. Device-level results are the arithmetic means of the ten fold-trained independent-test evaluations.

Because the device subsets have non-identical feature spaces and unequal independent-test sizes, the primary TON-IoT summary is the unweighted mean of the seven device-level fold means. A sensitivity analysis also weights those device-level means by their independent-test sizes. The latter is a sample-size-weighted average of device summaries, not a pooled prediction-level metric. Both summaries support secondary-benchmark comparison, but neither should be interpreted as direct zero-shot transfer or fully harmonized pooled evaluation across all devices.

Table 3 summarizes the dataset configuration, task formulation, split construction, sampler usage, and transparency notes used in the experimental protocol.

Table 3. Dataset and evaluation protocol configuration used in this study.

3.3 Preprocessing and split construction

For the DataSense experiments, the preprocessed dataset was first divided once into a training/validation pool and an independent test set using a stratified 80/20 split. The training/validation pool contained 437,974 samples, and the independent test set contained 109,494 samples. The resulting class counts for the full dataset, training/validation pool, and independent test set are shown in Table 2. The independent test set was not used for feature selection, common-feature selection, scaling, model fitting, hyperparameter selection, or early stopping.

Within the training/validation pool, stratified 10-fold train/validation splitting was repeated across three controlled random seeds, S = {42, 52, 62}. For each model, seed, and fold, the fold-training subset was used to fit the Random-Forest-based feature selector, numerical scaler, and required transformations. The fitted selector, scaler, and transformations were then applied unchanged to the fold-validation subset and to the independent test set. This design ensures that supervised feature selection and preprocessing were confined to the corresponding fold-training data.

RF-RFE used a Random Forest estimator with 100 trees, Gini criterion, maximum depth of 20, max_features="sqrt", class_weight="balanced", n_jobs=15, and a fold-specific random state defined as the current seed plus the fold number. Recursive Feature Elimination selected 60 features per fold-specific run using a step size of 15. Across the 30 seed-fold RF-RFE runs, 55 features were selected in all runs and were retained as the common feature set for the final DataSense comparison.

The weighted random sampler was constructed only from the fold-training subset and was not applied to validation or test data. Model training was performed on the transformed fold-training subset, and the best epoch was selected using validation loss on the fold-validation subset. The selected fold-trained model was then evaluated on the fixed independent test set. Let q_{*m, s, k*} denote an independent-test metric for model m, seed s, and fold-trained model k. The ten fold-trained evaluations were first averaged within each seed:

qm,s=1K∑k=1Kqm,s,k, K=10.(1)

The final mean and sample standard deviation were then computed only across the n = 3 seed-level summaries:

q̄m=1n∑s=1nqm,s, sq,m=1n-1∑s=1n(qm,s-q̄m)2, n=3.(2)

Because only three seed-level observations were available, the reported 95% confidence-interval half-width uses the two-sided Student's t critical value with two degrees of freedom:

h95=t0.975,n-1sq,mn=4.3027sq,m3,

CI95=[q̄m-h95,q̄m+h95].(3)

All calculations use the unrounded fold-level metric values. The intervals are presented as descriptive uncertainty summaries rather than as evidence of statistical significance because n = 3. The workflow is illustrated in Figure 1. Algorithm 1 summarizes the loop structure used to implement the leakage-controlled repeated-seed evaluation.

Algorithm 1 Leakage-controlled repeated-seed evaluation protocol. Algorithm pseudocode in black text on a white background describes a machine learning procedure with steps to train and validate models using stratified 10-fold cross-validation, Random-Forest-based feature selection, scaling, and seed averaging on the DataSense dataset, explicitly detailing steps from data splitting to evaluating metrics and summarizing results.

3.4 CKAN-AFG architecture

CKAN-AFG is a compact non-recurrent KAN-centered IDS architecture designed for missed-attack-risk-oriented IIoT intrusion detection. The model combines a CKAN-based input stem, a residual FastKAN-inspired feature-transformation block, residual multi-head feature attention, channel-wise feature gating, adaptive average pooling, and a compact KANLinear classification head.

As shown in Figure 2, CKAN-AFG follows a compact non-recurrent pipeline that begins with input normalization and a CKANStem, followed by a residual FastKAN-inspired feature-transformation block, residual multi-head feature attention, feature gating, adaptive pooling, and a compact KANLinear classifier.

Given an input tensor with shape B×1 × F, where B is the batch size and F is the number of input features, CKAN-AFG first applies one-dimensional batch normalization to stabilize the input distribution. A shallow CKANStem then maps the single-channel input into a 64-channel hidden representation using KANConv1D, batch normalization, and SiLU activation. This stem provides an initial KAN-based local feature-interaction stage before the residual FastKAN-inspired nonlinear transformation block.

The hidden representation is then passed through a residual FastKAN-inspired block. The block includes two FastKANConv1D transformations with kernel size 3, padding 1, grid size 3, grid range [−1, 1], SiLU activation, dropout, and a learnable residual scaling coefficient initialized to 0.5. The residual formulation is used to preserve stable feature propagation while allowing nonlinear feature refinement.

After the residual FastKAN-inspired block, CKAN-AFG applies residual multi-head feature attention with four attention heads, motivated by attention-based representation refinement in deep neural architectures (Vaswani et al., 2017). The attention module refines the learned representation by emphasizing informative feature relationships. This component is included because subtle attack indicators may be sparse or partially masked by dominant benign or majority-class behavior. The attention output is added residually to the incoming representation.

The attention-refined representation is then passed through a feature-gating module. The gate uses global average pooling followed by a two-layer gating network with SiLU activation, dropout, and sigmoid recalibration. This follows the general principle of channel-wise recalibration, where informative channels are strengthened and less informative channels are suppressed (Hu et al., 2018). The resulting gate is applied channel-wise to strengthen channels that contribute to attack discrimination. This stage supports the model's objective of improving separation in ambiguous or minority attack regions.

Finally, the post-gate representation is normalized, compressed using adaptive average pooling to length 8, flattened, and passed through a lightweight pre-classifier stabilization step consisting of LayerNorm, SiLU activation, and dropout. Classification is performed using a single KANLinear layer with grid size 5 and spline order 2. This keeps classifier-side complexity limited while preserving the KAN-centered representation philosophy of the model.

The architecture is intentionally non-recurrent. Unlike the earlier CKAN–BiLSTM model, which combined CKAN feature extraction with BiLSTM-based recurrent processing and attention, CKAN-AFG avoids recurrent modeling and instead focuses on compact feature transformation, residual feature refinement, and channel recalibration. This design supports the paper's objective of evaluating missed-attack reduction under deployment-oriented constraints rather than simply increasing hybrid modeling capacity.

Algorithm 2 summarizes the CKAN-AFG forward pass. The algorithm is included to clarify how compact KAN-based feature transformation, residual feature refinement, channel-wise recalibration, adaptive pooling, and KAN-based classification are organized in the proposed architecture.

Algorithm 2 CKAN-AFG forward pass. Algorithm diagram displays pseudocode for a neural network pipeline with sequential operations such as BatchNorm1D, FastKANConv1D, SiLU, Dropout, residual scaling, multi-head attention, channel recalibration, pooling, flattening, normalization, and KANLinear classifier, followed by output logits computation.

3.5 Comparison models

CKAN-AFG is compared with retained models representing different architectural families. CKAN–BiLSTM is included as the primary continuity baseline because it represents the earlier hybrid KAN-based IIoT IDS model. Hybrid-CNN-LSTM and DDCNN-BiLSTM are retained as convolutional–recurrent deep-learning comparison models. These models provide context for evaluating whether the proposed compact non-recurrent CKAN-AFG architecture improves missed-attack behavior and deployment-oriented trade-offs relative to both KAN-based and conventional hybrid baselines.

The purpose of the comparison is not to claim exhaustive superiority over all possible IDS models. Instead, the retained baselines are used to evaluate CKAN-AFG against representative architectures under a shared preprocessing, split, training, and metric-computation protocol. The main contribution remains the missed-attack-risk-oriented CKAN-AFG design, its KAN-isolation and component-level ablation analysis, and its deployment-oriented error–efficiency interpretation.

To isolate the contribution of the KAN-specific components, two additional complete non-KAN replacement baselines were evaluated as part of the ablation analysis. In the CNN replacement baseline, KANConv1D/FastKANConv1D transformations were replaced with conventional Conv1D blocks, and the KANLinear classifier was replaced with a standard nn.Linear classifier. In the LSTM replacement baseline, KANConv1D/FastKANConv1D transformations were replaced with LSTM-based recurrent encoders, and the KANLinear classifier was again replaced with a standard nn.Linear classifier. These replacement baselines were designed to test whether the KAN-based feature-transformation and classifier components provide an advantage beyond conventional neural alternatives.

3.6 Ablation design

A KAN-isolation and component-level ablation study is used to examine which architectural choices contribute to the missed-attack-risk objective. The ablation focuses on CKAN-AFG because its KAN-centered feature transformation, residual attention, and feature-gating components are the proposed contribution being tested.

Six variants are evaluated. The first is the full CKAN-AFG model, which includes CKANStem, a residual FastKAN-inspired feature-transformation block, residual multi-head feature attention, feature gating, adaptive pooling, and a compact KANLinear classifier. Two complete non-KAN replacement baselines are then included to isolate the contribution of the KAN-specific transformations. In the CNN replacement baseline, the KANConv1D/FastKANConv1D transformations are replaced by conventional Conv1D residual blocks, and the KANLinear classifier is replaced by a standard nn.Linear classifier. In the LSTM replacement baseline, the KANConv1D/FastKANConv1D transformations are replaced by LSTM-based residual blocks, and the KANLinear classifier is replaced by a standard nn.Linear classifier.

Three additional component ablations are used to isolate the refinement mechanisms of CKAN-AFG. The NoAttention variant removes the residual multi-head feature-attention module. The NoGate variant removes the channel-wise feature-gating module. The NoAttention-NoGate variant removes both refinement mechanisms simultaneously while retaining the CKANStem and residual FastKAN-inspired feature-transformation block. These component ablations test whether attention and gating improve the missed-attack-risk profile beyond the KAN-based feature-transformation backbone.

The KAN-isolation and component-ablation experiments were conducted under the leakage-controlled 60-feature RF-RFE protocol using the same three controlled seeds, ten folds, split assignments, training settings, and hyperparameters across variants. GPU execution was used only to accelerate these ablation runs. Therefore, the ablation table reports predictive metrics and parameter counts, while final CPU runtime and deployment-oriented efficiency conclusions are reported separately under the 55-common-feature protocol.

3.7 Evaluation metrics

The evaluation combines conventional classification metrics, false-negative-aware measures, and deployment-oriented efficiency metrics.

Predictive performance is measured using accuracy, balanced accuracy, support-weighted precision, support-weighted recall, and support-weighted F1-score. Let C denote the number of classes, N_*c* the support of class c, N=∑c=1CNc, and P_*c*, R_*c*, and F1_*c* the one-vs-rest precision, recall, and F1-score for class c. The reported weighted metrics are

Pw=∑c=1CNcNPc, Rw=∑c=1CNcNRc, F1w=∑c=1CNcNF1c.(4)

Balanced accuracy is the unweighted mean of the class recalls:

BA=1C∑c=1CRc.(5)

The weighting convention is stated explicitly because the support-weighted scores summarize performance under the observed class distribution, while balanced accuracy and the class-level outputs retain visibility into minority-class behavior.

False-negative-aware evaluation uses FNR, true positive rate, negative predictive value, and operational error decomposition derived from the multiclass confusion matrix. For multiclass attack evaluation, an attack-class error occurs when a sample belonging to an attack class is predicted as any other class. However, this manuscript further separates such errors into operationally different categories. An attack sample predicted as Benign is treated as a true missed attack. An attack sample predicted as another attack family is treated as attack-family misclassification. A benign sample predicted as an attack is treated as a false alarm. This distinction is important because the paper evaluates not only aggregate multiclass detection, but also the operational meaning of the remaining errors.

False-positive behavior is measured using false-positive rate and true-negative rate. These metrics are reported alongside FNR because a useful IDS should reduce true missed attacks without producing an unacceptable false-alarm burden. The evaluation therefore prioritizes FNR, FPR, operational error decomposition, repeated-seed stability, and deployment-oriented efficiency because these measures directly support the missed-attack-risk-oriented focus of the study.

Deployment-oriented efficiency is evaluated using trainable parameter count, FP32 model size, FLOPs/MACs, total test time, inference time per sample, and throughput. These metrics are interpreted jointly with false-negative-aware performance because the goal is not only to identify the fastest or smallest model, but to determine whether the model provides a defensible trade-off between missed-attack reduction and computational cost.

Because this study is centered on missed-attack risk, FNR is treated as a primary evaluation metric. For the multiclass results, the reported FNR is the macro-average of the one-vs-rest class-specific false-negative rates:

FNRmacro=1C∑c=1CFNcTPc+FNc=1-BA.(6)

Because this macro average includes the Benign class as well as the seven attack classes, it is a class-balanced one-vs-rest error summary rather than a direct attack-to-benign miss rate. True operational misses are reported separately through the attack-to-benign count in Table 4.

Table 4. Operational error decomposition from the fully recorded 8-class confusion matrices of the final 55-common-feature DataSense verification rerun.

Attack → Benign corresponds to true missed attacks; Attack → Attack corresponds to attack-family misclassification; Benign → Attack corresponds to false alarms. Values are mean counts per fold-trained independent-test evaluation, first averaged within seed and then across the three seeds. Lower is better for all columns. Bold indicates the lowest (best) value within each error-count column.

The reported FPR and NPV are likewise macro-averaged across the one-vs-rest class calculations:

FPRmacro=1C∑c=1CFPcFPc+TNc,

NPVmacro=1C∑c=1CTNcTNc+FNc.(7)

When comparing CKAN-AFG with the CKAN–BiLSTM continuity baseline, the relative FNR reduction is computed as:

ΔFNR=FNRbaseline-FNRCKAN-AFGFNRbaseline×100.(8)

This operational distinction is used in Table 4 to separate true missed attacks from attack-family misclassifications and false alarms.

3.8 Implementation details

All models were implemented in Python 3.13.9 using PyTorch 2.11.0+cu128, NumPy 2.3.5, pandas 2.3.3, and scikit-learn 1.7.2. CUDA 12.8 was available in the experimental environment. The main DataSense experiments followed the 55-common-feature protocol described in Section 3, using three controlled random seeds, stratified 10-fold train/validation splitting within the training/validation pool, and evaluation on the fixed independent test set.

Models were trained using the Adam optimizer and cross-entropy loss for multiclass classification. The learning rate was set to 1 × 10⁻⁴, the maximum training budget was 40 epochs, and early stopping monitored validation loss with a patience of 15 epochs. A batch size of 2,056 was used in the experiments. Random seeds controlled data partitioning within the training/validation pool, model initialization, sampler behavior, and stochastic optimization.

The retained models used the same preprocessing pipeline, seed-controlled stratified fold-construction procedure, selected common-feature set, learning rate, batch size, maximum epoch budget, early-stopping patience, and metric-computation procedure. The WeightedRandomSampler was applied only to training data. Validation and test data were evaluated under their original class distributions.

For TON-IoT, the same four retained architectures were evaluated independently on each of the seven device subsets using fixed seed 1. Each device first used the approximately stratified 80/20 split reported in Table 5; the ten fold-specific models were then trained using train/validation folds drawn only from the corresponding training/validation pool and evaluated on the fixed independent test set. Every architecture was reinitialized and retrained separately for each device and fold. The input matrices contained independent tabular records rather than sliding windows or multi-record sequences, and all models received identical records, partitions, preprocessing, feature representation, and batch size within a device. The support-weighted F1-score and macro one-vs-rest FNR were computed for each fold, then averaged across the ten fold-trained test evaluations to obtain each device-level result.

TON-IoT device-level matrix dimensions, results, and aggregate sensitivity analysis.

Table 5.

Table 6.

Table 7.

Panel A reports the input-feature count (F), training/validation-pool and independent-test sample sizes, and device-level support-weighted F1-score. Panel B reports device-level macro FNR. Both metric panels report means of ten fold-trained independent-test evaluations for fixed seed 1. Weighted-F1 is support weighted within each device; FNR is the macro average of one-vs-rest class-specific false-negative rates. In Panel C, bold indicates the best value within each metric column. All metric values are percentages. In Panel C, bold indicates the best value within each metric column (higher is better for weighted F1-score; lower is better for FNR).

Runtime profiling for the final 55-common-feature comparison was conducted using CPU-only execution with the same machine, batch size, and measurement procedure for all retained models. For the final runtime measurements, model execution and tensor operations were explicitly kept on CPU, and CUDA acceleration was not used for the reported timing values. The profiling machine used an Intel Core i7 processor with 14 cores and 32 GB RAM. No warm-up stage was used. Runtime values were averaged across the three controlled seeds and ten folds per seed. GPU-based execution was used only to accelerate the 60-feature KAN-isolation and component-ablation experiments and is not used for the final CPU deployment-oriented comparison. The GPU available for those accelerated ablation runs was an NVIDIA RTX A2000 8GB Laptop GPU.

The original experiment did not retain sample-level train/test split indices, fold-index arrays, or sample-level prediction vectors. To provide verifiable evidence during the current review without overstating the artifacts available from that execution, the final 55-common-feature protocol was repeated under the same dataset split counts, model configurations, seeds, stratified 10-fold procedure, training settings, and metric definitions, with expanded output capture. This controlled verification rerun saved all 240 fold-level confusion matrices (120 independent-test and 120 validation matrices), the corresponding seed-aggregated sum and mean matrices, seed-aggregated per-class precision, recall, F1-score, and support, and fold-aggregated class-pair prediction counts. Tables 4, 6, 7, together with their dependent DataSense statements, use this fully auditable rerun as the canonical predictive-results source. The current-review supporting package also provides a file inventory with SHA-256 checksums and machine-readable audit summaries.

Table 6. Independent-test detection performance on DataSense from the fully recorded verification rerun of the final DoS/DDoS-separate 55-common-feature protocol.

The ten fold-trained independent-test evaluations were first averaged within each seed; means and sample SDs were then computed across the three seed-level values (n = 3). CI95 is the two-sided Student's t confidence-interval half-width, t0.975,2s/3. Higher is better for Accuracy, Balanced Accuracy, weighted Precision, weighted Recall, weighted F1-score, and NPV; lower is better for FNR and FPR. Bold indicates the best mean value within each metric column (higher is better for Accuracy, Balanced Accuracy, weighted Precision, weighted Recall, weighted F1-score, and NPV; lower is better for FNR and FPR).

Table 7. Repeated-seed stability of weighted F1-score and FNR from the fully recorded verification rerun of the final 55-common-feature DataSense protocol.

Values are reported as mean ± sample standard deviation across the three seed-level summaries (n = 3). The CI95 column gives the two-sided Student's t half-width, t0.975,2s/3. Higher is better for weighted F1-score; lower is better for FNR. Bold indicates the best mean value for each metric (higher is better for weighted F1-score; lower is better for FNR).

4 Results

This section reports the experimental results around the five primary questions that define the contribution of this paper: whether CKAN-AFG reduces true missed attacks, where residual error remains, which architectural components contribute to the reduction, what deployment cost is paid, and whether the behavior remains consistent beyond the main benchmark. The analysis also includes a repeated-seed stability analysis to examine whether the primary DataSense findings remain consistent across the controlled seed-level summaries. Because all retained models achieve near-ceiling accuracy on DataSense, the analysis emphasizes false-negative rate (FNR), weighted F1-score, operational error decomposition, ablation behavior, repeated-seed stability, and deployment-oriented efficiency rather than accuracy alone.

4.1 Does CKAN-AFG reduce false-negative behavior on DataSense?

Table 6 reports independent-test performance on the CIC IIoT Dataset 2025 (DataSense) under the DoS/DDoS-separate setting using the final 55-common-feature protocol. Values are summarized across three controlled random seeds after averaging the ten fold-trained independent-test evaluations within each seed, following the leakage-controlled procedure described in Section 3.3.

All retained models achieve high aggregate performance, with independent-test accuracy above 99.7%. However, accuracy alone is not sufficiently informative because the models operate near ceiling-level performance. The false-negative-aware metrics provide a clearer distinction. CKAN-AFG achieves the strongest overall profile, with the highest accuracy (99.8147%), highest balanced accuracy (99.7364%), highest weighted F1-score (99.8146%), lowest FNR (0.2636%), lowest FPR (0.0290%), and highest NPV (99.9728%).

Compared with CKAN–BiLSTM, CKAN-AFG reduces FNR from 0.2792% to 0.2636%, corresponding to an approximately 5.6% relative FNR reduction. Compared with Hybrid-CNN-LSTM and DDCNN-BiLSTM, the relative FNR reductions are approximately 18.7% and 28.4%, respectively. Although the absolute differences are small because the benchmark is highly separable, these differences remain important under the missed-attack-risk framing because the reported macro FNR summarizes the residual class-level one-vs-rest error profile, while Table 4 separately isolates true operational misses.

The leakage-controlled 55-common-feature results therefore support a more cautious but still positive conclusion. CKAN-AFG does not dramatically change already high aggregate accuracy, but it provides the best false-negative-aware operating point among the retained models under the final DataSense protocol. This result supports the central argument that compact KAN-centered feature refinement can reduce the remaining missed-attack-oriented error profile without relying on accuracy alone.

4.2 Where do residual missed detections remain?

Aggregate macro FNR summarizes the overall class-level one-vs-rest error profile, but it does not distinguish operationally different error types. To provide this distinction, Table 4 decomposes the seed-aggregated multiclass confusion matrices into three operational categories: attack samples predicted as Benign, attack samples predicted as another attack family, and benign samples predicted as an attack.

This distinction is important for IIoT intrusion detection. Attack-to-benign errors represent true missed attacks because malicious traffic is classified as benign. Attack-to-attack errors represent attack-family misclassification because the sample is still recognized as malicious but assigned to the wrong attack category. Benign-to-attack errors represent false alarms. Values in Table 4 are mean counts computed from the fully recorded fold-level confusion matrices of the final-protocol verification rerun, first averaged within seed and then across the three seeds.

CKAN-AFG produces the lowest attack-to-benign count, with 33.8 mean true missed attacks, compared with 39.4 for CKAN–BiLSTM, 46.3 for Hybrid-CNN-LSTM, and 53.2 for DDCNN-BiLSTM. CKAN-AFG also produces the lowest attack-to-attack misclassification count and the lowest total off-diagonal error count. Compared with CKAN–BiLSTM, CKAN-AFG reduces attack-to-benign errors by approximately 14.1% and total off-diagonal errors by approximately 9.2%.

The main observation is that most residual errors are not attacks being completely hidden as benign traffic, but attack-family confusions within malicious classes. This supports the missed-attack-risk framing while avoiding the misleading interpretation that every multiclass false negative is an operationally undetected attack.

4.3 Which CKAN-AFG components contribute to missed-attack reduction?

Table 8 summarizes the KAN-isolation and component-ablation results. Unlike the main 55-common-feature comparison in Table 6, this ablation analysis was conducted under the leakage-controlled 60-feature RF-RFE protocol described in Section 3.6. The purpose of this table is to isolate architectural effects rather than to report deployment timing. Therefore, only predictive metrics and parameter counts are reported.

Table 8. KAN-isolation and component-ablation analysis for CKAN-AFG under the leakage-controlled 60-feature RF-RFE protocol.

Values are mean independent-test results across three controlled seeds after averaging the ten fold-trained models per seed. The CNN and LSTM variants are complete non-KAN replacement baselines in which KANConv1D/FastKANConv1D transformations and the KANLinear classifier were replaced by conventional neural components. Higher is better for Accuracy, weighted F1-score, and NPV; lower is better for FNR and FPR. Bold indicates the best predictive value within each metric column (higher is better for Accuracy, weighted F1-score, and NPV; lower is better for FNR and FPR).

The complete CKAN-AFG model achieves the strongest ablation profile, with the highest weighted F1-score (99.8250%) and the lowest FNR (0.2350%). The CNN complete non-KAN replacement baseline is parameter-comparable to CKAN-AFG, but its FNR increases to 0.3410%. The LSTM complete non-KAN replacement baseline has a larger parameter count than CKAN-AFG, but its FNR also increases to 0.2980%. This supports the conclusion that the KAN-specific feature-transformation and classifier components contribute to the missed-attack-risk profile beyond conventional Conv1D or LSTM replacements.

The component ablations show a similar pattern. Removing residual attention increases FNR to 0.3220%, removing the feature gate increases FNR to 0.3170%, and removing both refinement mechanisms increases FNR to 0.3270%. These results indicate that attention and feature gating both contribute to the full model's missed-attack-risk behavior, while the complete CKAN-AFG design provides the best overall false-negative-aware profile among the evaluated variants.

Taken together, the ablation results support two conclusions. First, replacing the KAN-specific feature-transformation and classifier components with conventional CNN or LSTM alternatives degrades the false-negative-aware profile, even when the CNN replacement remains parameter-comparable to the full model. Second, removing attention, feature gating, or both also increases FNR relative to the complete CKAN-AFG design. The evidence therefore supports a cautious architectural conclusion: CKAN-AFG's strongest missed-attack-risk profile comes from the combination of KAN-based transformation, residual attention, and feature gating, rather than from any single component alone.

4.4 What deployment cost is paid for the missed-attack reduction?

Table 9 reports the CPU-based deployment-oriented efficiency profile for the retained models under the final 55-common-feature protocol. All values were measured using the same batch size and CPU-based profiling procedure. GPU-accelerated ablation timings are not included in this table.

Table 9. CPU-based deployment-oriented efficiency comparison on DataSense under the final 55-common-feature protocol.

Runtime values were measured using CPU execution with batch size 2056. Lower is better for parameters, FP32 size, FLOPs, MACs, total test time, and time per sample; higher is better for throughput.

CKAN-AFG is not the fastest retained model in raw inference speed. DDCNN-BiLSTM and Hybrid-CNN-LSTM achieve higher CPU throughput and lower inference time per sample. However, CKAN-AFG is faster than the CKAN–BiLSTM continuity baseline and remains smaller than the retained convolutional–recurrent baselines. CKAN-AFG uses 247,005 trainable parameters, occupies 0.956 MB in FP32 format, and processes approximately 1,691 samples/s under the reported CPU-only profiling setting.

These results place CKAN-AFG in a middle operating region. It is not the minimum-latency model, but it provides the strongest false-negative-aware profile in Table 4 while remaining compact and computationally practical. In missed-attack-oriented IIoT monitoring, this trade-off is defensible because the cost of true missed attacks may be higher than the cost of modest additional computation, provided that latency and model size remain practical.

4.5 Does the behavior remain consistent beyond DataSense?

Table 5 reports the seven TON-IoT device-level results and their corresponding independent-test sample sizes. Within each device, support-weighted F1-score and macro one-vs.-rest FNR are the means of the ten fold-trained evaluations on the fixed independent test set. The table also reports both the unweighted device mean and a sample-size-weighted sensitivity summary. For metric q, these summaries are

q̄U=17∑d=17q̄d, q̄W=∑d=17Ndq̄d∑d=17Nd,(9)

where q̄d is the fold-mean test result for device d and N_*d* is that device's independent-test size. The weighted summary is a sensitivity analysis over device-level means and is not a substitute for pooling sample-level predictions across heterogeneous feature spaces.

The final TON-IoT results show that CKAN-AFG achieves the highest device-average support-weighted F1-score under both summaries: 99.4009% unweighted and 99.4182% sample-size weighted. Relative to CKAN–BiLSTM, CKAN-AFG increases weighted F1-score by 0.0687 percentage points under the unweighted summary and 0.0667 percentage points under the sample-size-weighted summary. Its macro FNR decreases from 0.7126% to 0.5644% in the unweighted comparison, a 20.8% relative reduction, and from 0.6382% to 0.4915% in the weighted sensitivity comparison, a 23.0% relative reduction. DDCNN-BiLSTM nevertheless achieves the lowest TON-IoT macro FNR under both summaries. Thus, CKAN-AFG improves over the continuity baseline and leads on device-average weighted F1-score, but it is not universally best on every TON-IoT metric.

Six TON-IoT inputs were derived from timestamps. Because the evaluation used one-record feature vectors rather than multi-record sequences, these fields provide within-record temporal context but do not establish that any model learned inter-record temporal dependencies. Their contribution to the observed ranking cannot be isolated without a temporal-feature ablation. The cross-dataset findings should therefore be interpreted cautiously: CKAN-AFG provides the strongest false-negative-aware profile on the primary DataSense benchmark, achieves the strongest TON-IoT device-average weighted F1-score, and improves over CKAN–BiLSTM under both TON-IoT aggregation choices, while DDCNN-BiLSTM attains the lowest TON-IoT device-average FNR.

4.6 Repeated-seed stability of the primary DataSense results

To examine whether the primary missed-attack-risk results are stable across controlled random seeds, Table 7 summarizes repeated-seed stability for weighted F1-score and FNR under the final 55-common-feature DataSense protocol. These values are computed across the three seed-level summaries after averaging the ten fold-trained independent-test evaluations within each seed. Thus, the table summarizes repeated-seed variability rather than pooled fold-level variability.

The repeated-seed results support the stability of the primary findings. CKAN-AFG achieves the highest weighted F1-score mean and the lowest FNR mean among the retained models. Its weighted F1-score sample standard deviation is 0.0052 percentage points, and its FNR sample standard deviation is 0.0191 percentage points. The corresponding t-based CI95 half-widths are 0.0130 and 0.0474 percentage points, respectively. These descriptive summaries indicate that the false-negative-aware advantage observed in the main DataSense comparison remains consistent across the three controlled seed-level evaluations, while the comparatively wider FNR interval is retained explicitly rather than masked by pooling fold-level observations.

4.7 Summary of results

The results support the argument of the paper. First, under the final leakage-controlled 55-common-feature DataSense protocol, CKAN-AFG achieves the strongest false-negative-aware profile among the retained models, with the highest weighted F1-score, lowest FNR, and lowest FPR. Compared with the CKAN–BiLSTM continuity baseline, CKAN-AFG reduces FNR from 0.2792% to 0.2636%, corresponding to an approximately 5.6% relative FNR reduction.

Second, the operational error decomposition shows that the residual multiclass errors should not all be interpreted as operationally undetected attacks. CKAN-AFG produces the lowest attack-to-benign count, with 33.8 mean true missed attacks, and the lowest total off-diagonal error count among the retained models. Most remaining errors correspond to attack-family misclassification rather than attacks being classified as benign traffic.

Third, the KAN-isolation and component-ablation results show that replacing the KAN-specific feature-transformation and classifier components with conventional CNN or LSTM alternatives increases FNR. Removing attention, feature gating, or both also increases FNR relative to the complete CKAN-AFG design. These results support the conclusion that CKAN-AFG's missed-attack-risk profile comes from the combined effect of KAN-based transformation, residual attention, and feature gating.

Fourth, CKAN-AFG is not the fastest retained model, but it provides a deployment-oriented middle operating point. It is faster than the CKAN–BiLSTM continuity baseline, smaller than the retained convolutional–recurrent baselines, and achieves the strongest false-negative-aware profile on the primary benchmark. Fifth, the TON-IoT comparison shows that CKAN-AFG achieves the highest device-average weighted F1-score and improves over CKAN–BiLSTM under both unweighted and test-size-weighted summaries, while DDCNN-BiLSTM achieves the lowest device-average FNR. Sixth, the repeated-seed stability analysis shows that CKAN-AFG maintains the highest weighted F1-score mean and lowest FNR mean across the controlled seed-level summaries.

Overall, the strongest evidence for CKAN-AFG does not come from accuracy alone. It comes from the combined view of FNR reduction, operational error decomposition, KAN-isolation and component-ablation evidence, cross-dataset comparison across independent device profiles, repeated-seed stability, and deployment-oriented efficiency. This supports the central claim that compact KAN-centered feature refinement can provide a practical operating point for missed-attack-risk-oriented IIoT intrusion detection without overclaiming universal dominance or direct zero-shot transfer.

5 Discussion

The results support the central argument of this study: compact KAN-centered feature refinement can improve the false-negative-aware operating profile of IIoT intrusion detection while maintaining a deployment-oriented efficiency profile. The contribution should not be interpreted as a generic claim that CKAN-AFG is universally superior to all IDS architectures. Instead, the evidence shows that CKAN-AFG provides the strongest missed-attack-risk-oriented profile on the primary DataSense benchmark, improves over the CKAN–BiLSTM continuity baseline on both DataSense and TON-IoT, and exposes a defensible trade-off between true missed-attack reduction and computational cost.

5.1 Interpreting near-ceiling performance

A key challenge in interpreting the results is that all retained models achieve very high aggregate accuracy on DataSense. In such near-ceiling settings, small differences in accuracy or weighted F1-score may appear numerically minor, but differences in false-negative behavior remain operationally meaningful. This is especially important in IIoT environments, where false negatives may correspond to malicious activity that remains undetected or incorrectly characterized. For this reason, the evaluation focuses on FNR, operational error decomposition, repeated-seed stability, and deployment-oriented efficiency rather than accuracy alone.

Under the final leakage-controlled 55-common-feature protocol, CKAN-AFG reduces FNR from 0.2792% for the CKAN–BiLSTM continuity baseline to 0.2636%, corresponding to an approximately 5.6% relative FNR reduction. Compared with Hybrid-CNN-LSTM and DDCNN-BiLSTM, the relative FNR reductions are approximately 18.7% and 28.4%, respectively. These improvements are modest in absolute percentage terms because the benchmark is highly separable for all retained models, but they are meaningful under a missed-attack-risk interpretation because they occur in the residual error region after aggregate performance has already saturated.

The repeated-seed stability analysis further supports this interpretation. CKAN-AFG achieves the highest repeated-seed weighted F1-score mean and the lowest repeated-seed FNR mean among the retained models, with low seed-level variability. This suggests that the observed false-negative-aware advantage is not driven by a single seed-level summary, but remains consistent across the controlled repeated-seed evaluation.

5.2 Operational meaning of residual errors

The error analysis changes the interpretation of residual missed detections. Instead of treating every multiclass false negative as an operationally undetected attack, the paper separates attack-to-benign errors, attack-to-attack errors, and benign-to-attack errors. This distinction is important because an attack sample predicted as Benign represents a true missed attack, whereas an attack sample predicted as another attack family remains maliciously detected but incorrectly categorized.

Under this decomposition, CKAN-AFG produces the lowest attack-to-benign count, with 33.8 mean true missed attacks, compared with 39.4 for CKAN–BiLSTM, 46.3 for Hybrid-CNN-LSTM, and 53.2 for DDCNN-BiLSTM. CKAN-AFG also produces the lowest attack-to-attack count and the lowest total off-diagonal error count among the retained models. This supports a more precise interpretation of residual errors: most remaining errors are attack-family misclassifications rather than attacks being completely hidden as benign traffic.

This interpretation strengthens the operational relevance of the study. In IIoT monitoring, the difference between an attack classified as benign and an attack classified as the wrong attack family can affect triage urgency, response workflow, and containment strategy. The analysis therefore provides a clearer view of where residual risk remains and avoids overstating multiclass false negatives as uniformly undetected malicious traffic.

5.3 Role of KAN transformation, attention, and feature gating

The KAN-isolation and component-ablation results indicate that the full CKAN-AFG design provides the strongest false-negative-aware profile among the evaluated variants. Replacing the KAN-specific feature-transformation and classifier components with conventional CNN or LSTM alternatives increases FNR. The CNN replacement remains parameter-comparable to CKAN-AFG, but its FNR increases from 0.2350% to 0.3410%. The LSTM replacement has a larger parameter count than CKAN-AFG, but its FNR also increases to 0.2980%.

The component ablations show that residual attention and feature gating also contribute to the full model behavior. Removing attention increases FNR to 0.3220%, removing the feature gate increases FNR to 0.3170%, and removing both mechanisms increases FNR to 0.3270%. These results suggest that CKAN-AFG's strongest missed-attack-risk profile comes from the combination of KAN-based transformation, residual attention, and feature gating rather than from any single component alone.

This conclusion should still be interpreted cautiously. The ablation study supports architectural contribution under the retained benchmark protocol, but it does not prove that the same component ranking will hold under every dataset, feature space, or deployment condition. The value of the ablation is that it directly addresses whether the KAN-specific components and refinement mechanisms contribute beyond conventional neural replacements under a shared evaluation protocol.

5.4 Deployment trade-off

CKAN-AFG is not the fastest retained model. DDCNN-BiLSTM and Hybrid-CNN-LSTM achieve higher CPU throughput and lower inference time per sample. Therefore, the contribution should not be framed as minimum-latency inference or absolute speed. The more accurate interpretation is that CKAN-AFG occupies a middle operating region: it improves the false-negative-aware profile on the primary benchmark while remaining compact and computationally practical.

Under the final CPU-only profiling protocol, CKAN-AFG uses 247,005 trainable parameters, has a 0.956 MB FP32 footprint, and processes approximately 1,691 samples/s. It has the smallest parameter count among the four retained models and is faster than the CKAN–BiLSTM continuity baseline, although DDCNN-BiLSTM and Hybrid-CNN-LSTM remain faster in inference. Under the missed-attack-risk framing, lower latency alone does not determine the safest operating point when faster models leave more true attacks missed.

The deployment interpretation should therefore remain deployment-oriented rather than deployment-proven. The reported CPU profiling provides useful evidence of compactness and computational practicality under a controlled hardware and software setting, but it does not replace future benchmarking on industrial gateways, embedded CPUs, or edge accelerators.

5.5 Cross-dataset interpretation

The TON-IoT comparison provides useful but cautious secondary evidence. CKAN-AFG achieves the highest device-average support-weighted F1-score under both the unweighted summary (99.4009%) and the independent-test-size-weighted sensitivity summary (99.4182%). Relative to CKAN–BiLSTM, its macro FNR is lower under both summaries: 0.5644% vs. 0.7126% unweighted and 0.4915% vs. 0.6382% when weighted by device test size. These correspond to relative FNR reductions of 20.8% and 23.0%, respectively.

At the same time, DDCNN-BiLSTM achieves the lowest TON-IoT macro FNR under both aggregation choices. CKAN-AFG therefore does not dominate every retained model on every TON-IoT metric. The more credible conclusion is that it provides the strongest missed-attack-risk-oriented profile on the primary DataSense benchmark, improves over the CKAN–BiLSTM continuity baseline under both TON-IoT sensitivity summaries, and offers the strongest device-average weighted F1-score on the secondary benchmark.

All TON-IoT models received independent one-record tabular inputs rather than multi-record sequences. Six timestamp-derived variables supplied within-record temporal context, but no temporal-feature ablation was conducted. The observed ranking therefore cannot be attributed causally to those variables or to learned inter-record temporal dependencies. Because TON-IoT and DataSense also differ in feature spaces, device populations, attack taxonomies, and data-generation conditions, the TON-IoT analysis should be interpreted as comparison across independently retrained device profiles rather than direct zero-shot transfer or definitive deployment generalization.

5.6 Threats to validity

First, although the protocol confines Random-Forest-based Recursive Feature Elimination (RF-RFE) (Guyon et al., 2002) to the fold-training subset and keeps the independent test set separate from feature selection, common-feature selection, scaling, model fitting, hyperparameter selection, and early stopping, the DataSense evaluation remains a sample-level benchmark evaluation. Therefore, the results should be interpreted as leakage-controlled sample-level evidence rather than source-disjoint, device-disjoint, session-disjoint, temporal, or deployment validation. More generally, benchmark-based model comparison can still be affected by model-selection and evaluation-protocol choices, as discussed by Cawley and Talbot (2010).

Second, the repeated-seed protocol improves robustness relative to a single split, but it does not replace deployment-style validation. The same independent test set is used for fold-trained model evaluation within each seed, and the final summaries are computed across three seed-level values. This design reduces the risk of feature-selection leakage and seed-level sensitivity, but future work should evaluate CKAN-AFG under source-disjoint, device-disjoint, session-disjoint, temporal, or operationally realistic splits to better estimate generalization under changing IIoT conditions.

Third, the original experimental execution did not retain sample-level split indices, fold-index arrays, or sample-level prediction vectors. The current-review package therefore cannot reconstruct individual sample membership or sample-level predictions from that execution. To enable direct verification at the level of all reported aggregate metrics and class-pair error counts, the final protocol was repeated with complete fold-level validation and independent-test confusion-matrix capture, and the fully recorded rerun is used as the canonical predictive-results source. Future executions should additionally preserve immutable sample identifiers, exact index arrays, and sample-level prediction outputs from the outset.

Fourth, TON-IoT uses fixed seed 1 and reports device-level means across ten fold-trained evaluations, whereas the primary DataSense analysis uses three controlled seeds. The TON-IoT sensitivity analysis reports both an unweighted mean and an independent-test-size-weighted mean across seven heterogeneous device summaries; the latter is not a pooled prediction-level metric. In addition, the TON-IoT inputs are independent tabular records rather than multi-record temporal windows. Although six input variables are timestamp derived, their effect was not isolated by ablation. The TON-IoT findings should therefore be interpreted as single-seed comparative evidence across independently retrained device profiles, not direct zero-shot transfer, temporal-sequence validation, or definitive deployment generalization.

Fifth, the reported efficiency results are hardware- and implementation-dependent. Parameter count, FLOPs, MACs, and FP32 model size are useful indicators of computational profile, but test time, inference time per sample, and throughput depend on the software stack, batch size, hardware platform, and implementation details. Deployment on industrial gateways, embedded CPUs, or edge accelerators may produce different runtime behavior. Future work should therefore include hardware-specific benchmarking on realistic edge and gateway platforms.

Sixth, the evaluation focuses on supervised multiclass intrusion detection using labeled benchmark datasets. Real IIoT environments may involve concept drift, evolving attack behavior, partial labels, noisy labels, encrypted traffic, and adversarial adaptation. Future work should examine online updating, drift-aware evaluation, threshold tuning, uncertainty estimation, and adversarial robustness.

5.7 Practical implications

The main practical implication is that IIoT IDS evaluation should report more than aggregate accuracy. When models approach ceiling-level performance, small residual errors can still represent meaningful operational risk. Reporting FNR, FPR, operational error decomposition, repeated-seed stability, and deployment-oriented efficiency gives a clearer picture of whether a model is suitable for security monitoring.

For practitioners, the results suggest that CKAN-AFG is most useful when the objective is to reduce true missed attacks while preserving computational practicality. The model is not the fastest retained architecture, but it provides the strongest false-negative-aware profile on the primary DataSense benchmark and remains compact enough for further gateway-level or edge-assisted evaluation.

For researchers, the results highlight the importance of evaluating compact architectures not only by accuracy or parameter count, but also by the operational meaning of remaining errors. Separating attack-to-benign errors from attack-family misclassifications provides a more useful IDS interpretation than treating all multiclass false negatives as equally severe missed attacks.

5.8 Future work

Future work should extend this study in four directions. First, threshold-sensitivity analysis should examine whether CKAN-AFG can be tuned to reduce false negatives further without producing unacceptable false-positive rates. Second, deployment-style splits and explicitly constructed multi-record temporal windows should be used to test generalization across devices, sessions, sources, and time. Third, hardware-specific edge benchmarking should be conducted to validate whether the reported compactness and CPU profiling translate into practical real-time IIoT deployment. Fourth, future work should examine drift-aware evaluation, uncertainty estimation, and adaptation to evolving or previously unseen attack behavior.

6 Conclusion

This paper introduced and evaluated CKAN-AFG, a compact non-recurrent KAN-centered architecture for missed-attack-risk-oriented intrusion detection in Industrial Internet of Things environments. Rather than framing the contribution as another high-accuracy IDS model, the study focused on false-negative-aware behavior, operational error decomposition, KAN-isolation and component-level ablation, repeated-seed stability, cross-dataset behavior across independent device profiles, and deployment-oriented efficiency.

Under the final leakage-controlled 55-common-feature DataSense protocol, CKAN-AFG achieved the strongest false-negative-aware profile among the retained models, with a weighted F1-score of 99.8146% and an FNR of 0.2636%. Compared with the CKAN–BiLSTM continuity baseline, this corresponds to an approximately 5.6% relative FNR reduction. The operational error decomposition further showed that CKAN-AFG produced the lowest attack-to-benign count, with 33.8 mean true missed attacks, and the lowest total off-diagonal error count among the retained models. This distinction is important because it separates truly missed attacks from attack-family misclassifications and avoids treating all multiclass false negatives as equally undetected malicious traffic.

The KAN-isolation and component-ablation analysis showed that replacing the KAN-specific feature-transformation and classifier components with conventional CNN or LSTM alternatives increased FNR. Removing residual attention, feature gating, or both also degraded the false-negative-aware profile. These findings support the conclusion that CKAN-AFG's behavior comes from the combined effect of KAN-based transformation, residual attention, and feature gating rather than from any single component alone.

From a deployment-oriented perspective, CKAN-AFG is not the fastest retained model, but it provides a balanced middle operating point. Under CPU-only profiling, it used 247,005 trainable parameters, had a 0.956 MB FP32 footprint, and processed approximately 1,691 samples/s. It was faster than the CKAN–BiLSTM continuity baseline and smaller than the retained convolutional–recurrent baselines, while providing the strongest missed-attack-risk-oriented profile on the primary DataSense benchmark.

The seven-device TON-IoT comparison showed that CKAN-AFG achieved the highest device-average weighted F1-score and improved over CKAN–BiLSTM under both the unweighted and independent-test-size-weighted sensitivity summaries. DDCNN-BiLSTM nevertheless achieved the lowest TON-IoT device-average FNR. Because this single-seed secondary analysis used independently retrained one-record tabular inputs rather than multi-record temporal sequences, the conclusion is intentionally cautious: CKAN-AFG provides strong evidence for compact KAN-centered feature refinement as a practical operating point for missed-attack-risk-oriented IIoT intrusion detection, while future work should validate the model under repeated seeds, deployment-style temporal splits, evolving attack conditions, and realistic edge or gateway hardware.

Generative AI statement

The author(s) declared that Generative AI was used in the creation of this manuscript. During the preparation of this manuscript, the author(s) used OpenAI ChatGPT to assist with language refinement, organization, and manuscript editing. The author(s) reviewed, revised, and approved all AI-assisted content and take full responsibility for the accuracy, integrity, and originality of the manuscript. Generative AI was not used to generate experimental data, perform model training, compute results, create primary research findings, or make scientific conclusions.

Any alternative text (alt text) provided alongside figures in this article has been generated by Frontiers with the support of artificial intelligence and reasonable efforts have been made to ensure accuracy, including review by the authors wherever possible. If you identify any issues, please contact us.

Publisher's note

All claims expressed in this article are solely those of the authors and do not necessarily represent those of their affiliated organizations, or those of the publisher, the editors and the reviewers. Any product that may be evaluated in this article, or claim that may be made by its manufacturer, is not guaranteed or endorsed by the publisher.

Footnotes

Edited by: Ruben Ruiz-Gonzalez, University of Burgos, Spain

Reviewed by: Fortunatus Aabangbio Wulnye, IMT Atlantique, France

Marija Gombar, Oruzane Snage Republike Hrvatske, Croatia