A Novel Edge-Aware, Adversarial-Robust Lightweight Cybersecurity Scheme
for AI-Driven IoT Networked Systems
Abstract
IoT networks increasingly rely on machine-learning–based intrusion detection at the edge,
where models must operate under strict latency, memory, and power constraints while
remaining resilient to adaptive adversaries. This paper proposes a novel lightweight intrusion
detection scheme that integrates a compact TinyMLP classifier with adversarial training
(alternating FGSM/PGD), feature engineering tailored to flow dynamics, and an edge-aware
deployment workflow. The pipeline is end-to-end reproducible: it supports a BoT-IoT–style
multi-class traffic simulator and drop-in execution on widely used public datasets
(CICIDS2017, BoT-IoT, ToN_IoT); applies standardized preprocessing with rate/ratio features;
and benchmarks against enhanced baselines such as multinomial logistic regression, random
forest, XGBoost. Evaluation encompasses macro-F1, confusion matrices, and robustness
curves versus attack strength, alongside edge feasibility via per-sample latency and a simple
energy proxy. A federated extension illustrates non-IID learning without centralizing raw data.
Results indicate that the proposed approach sustains competitive macro-F1 on clean traffic
while degrading more gracefully under adversarial perturbations, offering a practical balance
between robustness and efficiency for gateways and microservers.
Keywords
IoT Security; Intrusion Detection System (IDS); Lightweight Deep Learning; Adversarial
Training; Edge Computing; BoT-IoT; CICIDS2017; ToN_IoT; Robustness Evaluation; MacroF1; Federated Learning; Network Traffic Analytics; TinyMLP; Adaptive Cyber Defense.
1. Introduction
The explosive growth of Internet-of-Things (IoT) deployments—ranging from smart homes
and industrial control to healthcare wearables and city-scale sensing—has fundamentally
shifted where and how it has defend networks. Billions of low-power devices now terminate,
generate, and relay traffic at the extreme edge, yet most classical security stacks were designed
for enterprise servers with generous compute, stable power, and centralized visibility. This
mismatch has created fertile ground for attackers: volumetric distributed denial-of-service
(DDoS) that conscripts insecure devices, low-and-slow exfiltration hidden inside legitimate
flows, and increasingly, adversarial manipulations targeting the machine-learning (ML)
models themselves. In this setting, the central research problem is to deliver robust intrusion
detection at the edge—where latency, memory, and energy budgets are tight—without
sacrificing detection quality or maintainability. The reason behind the Edge is Moving
detection closer to data sources reduces backhaul cost and response latency, enables privacypreserving analytics, and keeps gateways operational even when cloud connectivity is
degraded. But it also imposes unique constraints: gateways may run on single-board computers,
battery-powered relays, or microservers with limited RAM and no GPU; packet capture may
be partial; and firmware updates are infrequent. Designs that perform well in cloud labs often
fail under these realities. The reason behind the requirement of robustness is ML-based
intrusion detection systems (ML-IDS) can surpass signature methods by generalizing beyond
known indicators of compromise. However, small, structured perturbations to inputs—e.g.,
subtle timing, size, or sequence shifts within physically plausible bounds—can cause
misclassifications. Attackers can exploit such weaknesses to lower their detection probability
without triggering simple thresholds. Consequently, adversarial robustness is not a luxury addon; it is a primary requirement for sustained effectiveness in adversarial environments.
1.1 Problem Context and Practical Constraints
IoT flows differ from traditional enterprise traffic in several ways:
Heterogeneity and repeatability. Device behaviors are diverse (cameras, thermostats,
PLCs) yet often highly periodic. Attacks can mask within routine bursts or firmware
updates.
Resource ceilings. Edge gateways must preserve CPU for routing, memory for buffers,
and energy for uptime; IDS inference must operate within milliseconds per flow and
kilobytes of model state.
Intermittent connectivity. Models and rules cannot rely on continuous cloud access. Ondevice (or on-gateway) learning and adaptation are desirable but must be bandwidthaware.
Non-IID data. Different locations and tenants see different traffic mixes; centralized
training on pooled data may be infeasible or privacy-sensitive.
These realities lead to a dual objective: (i) high detection quality on clean traffic, and (ii)
graceful degradation under bounded, physically plausible adversarial perturbations, all under
strict latency, memory, and power constraints.
1.2 Threat Model and Scope
The Research focus on test-time evasion attacks against a supervised IDS that ingests per-flow
features (e.g., duration, packet/byte counts, TCP flag statistics, and derived rates/ratios). The
adversary perturbs features within an ℓ∞ budget ϵ that reflects small timing/size changes
achievable without breaking network semantics. The attacker does not poison training data,
manipulate labels, or compromise model parameters (poisoning and model theft are out of
scope for this paper). Under this model, our goal is to minimize robust risk—the worst-case
loss within the allowed perturbation budget—subject to edge resource constraints.
1.3 Research Gap
Existing IDS research typically optimizes one axis at a time:
Accuracy-centric deep models can achieve strong benchmarks but are too heavy for
edge gateways and seldom report end-to-end latency, memory footprint, or energy
implications.
Lightweight classical models (e.g., logistic regression, small trees) are deployable but
can be fragile under adversarial manipulations and evolving traffic distributions.
Robustness studies often evaluate on image domains or assume cloud-scale
training/inference; few provide a transparent, reproducible pipeline tailored to IoT
flows, with explicit trade-offs between robustness and deployability.
Federated approaches address privacy and heterogeneity, yet evaluations rarely couple
robustness with resource-aware edge inference.
Thus, there is a need for a unified, reproducible methodology that jointly pursues robustness
and deployability for IoT gateways, using metrics and artifacts that practitioners can trust and
reproduce.
1.4 Overview of the Proposed Approach
A novel edge-aware is introduced, adversarially-robust lightweight cybersecurity scheme for
AI-driven IoT networked systems. The core is a compact TinyMLP classifier (two small hidden
layers) trained with alternating FGSM/PGD adversarial training. This training strategy exposes
the model to complementary gradient landscapes—fast single-step (FGSM) and iterative
projected (PGD)—to smooth decision boundaries and improve worst-case behavior without
inflating model size.
The method integrates four design pillars:
1. Flow-centric feature engineering. In addition to raw counts (duration, packets, bytes,
flags) as it derive rates/ratios (packets per second, bytes per second, mean packet size,
inter-arrival time, SYN/ACK ratios) that capture temporal intensity and control
dynamics—often more discriminative and more stable than raw counts under benign
variability.
2. Lightweight architecture. The TinyMLP (input → 128 → 64 → classes) is deliberately
small to satisfy latency and memory ceilings while retaining enough capacity for multiclass discrimination (Normal, DoS, DDoS, PortScan, Exfiltration, etc.). Its fully
connected structure maps cleanly to quantized inference on edge CPUs.
3. Adversarial training for robustness. Each epoch alternates between FGSM and PGD
adversaries; clean and adversarial samples are mixed in training to maintain clean-data
accuracy while hardening against bounded perturbations.
4. Edge feasibility and transparency. The research benchmark against enhanced baselines
(multinomial logistic regression, random forest, XGBoost) and report macro-F1,
confusion matrices, and robustness curves (accuracy vs. ϵ). The research also measure
per-sample latency and a simple energy proxy (latency × parameter count for NN) to
reflect deployment costs. A small federated extension (FedAvg) demonstrates non-IID
adaptation without centralizing raw traffic.
1.5 Design Goals and Principles
The Methodology design is guided by six principles:
Robust-by-construction. Robustness is addressed in training (not only at test time) using
adversarial objectives aligned with the threat model.
Edge-first efficiency. Every architectural and preprocessing choice is justified with
latency/footprint implications; The Research prefer simple, vectorizable computations
and avoid heavy sequence models unless necessary.
Transparency and reproducibility. All steps—feature selection, splits, scaling,
hyperparameters, and attacks—are encoded in a single notebook with saved artifacts
(figures/CSVs) to promote validation and extension.
Metric balance. The Research elevate macro-F1 to avoid over-crediting majority
classes, and The Research visualize error structure via confusion matrices.
Deployment realism. The Research report wall-clock inference times on CPU to mirror
gateway realities; The Research include a simple energy proxy for comparative insight.
Adaptation path. The Research sketch a federated-ready update path for privacysensitive or bandwidth-limited settings subject to non-IID data.
1.6 Methodological Preview
Data & Features - The Research evaluate on a multi-class BoT-IoT–style simulator and offer
drop-in loaders for CICIDS2017, BoT-IoT, and ToN_IoT. Feature processing removes
constants, imputes/normalizes numerics (z-score), and constructs derived rates/ratios.
Baselines - The Research train multinomial logistic regression, random forest (≈300 trees), and
XGBoost (hist) to represent performant classical methods under edge constraints.
Proposed Model - The TinyMLP is trained with alternating FGSM/PGD and mixed clean/adv
batches to balance clean accuracy and adversarial robustness.
Evaluation - The Research report macro-F1/accuracy and confusion matrices (clean), then
robustness curves across ϵ ∈ {0.0,0.005,0.01,0.02,0.03,0.05}. Finally, The Research measure
per-sample latency and compute the energy proxy. A toy FedAvg demo quantifies non-IID
robustness of the training loop.
1.7 Anticipated Impact and Use Cases
Industrial gateways. Detect rate-based and stealthy abuse while staying within
millisecond-level inference budgets on x86/ARM microservers.
Smart buildings & campuses. Enforce per-device behavioral baselines; deploy
quantized TinyMLP at distribution switches or Wi-Fi controllers.
Healthcare & critical infrastructure. Enhance integrity monitoring where data locality
and reliability are paramount; pair robustness with federated adaptation to respect
privacy and regulatory constraints.
Managed IoT security services. Deliver reproducible, explainable scorecards and
artifacts to customers; tune ϵ to reflect risk appetite.
1.8 Contributions
The research makes four concrete contributions:
1. A novel, edge-aware, adversarially-robust lightweight IDS that integrates a compact
TinyMLP with alternating FGSM/PGD adversarial training and flow-centric features,
achieving a practical balance of accuracy, robustness, and efficiency for IoT gateways.
2. An end-to-end, reproducible evaluation pipeline (synthetic + real datasets) with
standardized preprocessing, robustness curves, confusion matrices, and edge-feasibility
metrics (latency/energy proxy), enabling transparent comparison and rapid replication.
3. A deployment-oriented analysis that quantifies per-sample inference cost and
parameter budgets, highlighting pathways to quantization/pruning without material loss
in macro-F1.
4. A federated-ready extension (toy FedAvg) demonstrating how the approach can adapt
to non-IID clients without centralizing raw data—an increasingly common requirement
in IoT environments.
It organises as like Section 2 reviews related work across ML-IDS, adversarial
robustness, and edge/federated learning. Section 3 formalizes the system and threat
models. Section 4 details the proposed methodology, including features, architecture,
and adversarial training. Section 5 describes datasets and experimental protocol.
Section 6 presents results on clean and adversarial traffic with latency/energy analysis.
Section 7 provides ablations and sensitivity studies. Section 8 discusses limitations,
ethics, and future work. Section 9 concludes.
Literature Survey
Methodology
A smart, edge-aware, adversarial-robust lightweight intrusion detection system (IDS) is
introduced for AI-driven IoT networks. The system ingests per-flow metadata, derives flowrate and ratio features, and performs classification on an edge gateway using a compact
TinyMLP architecture. Robustness against test-time evasion is attained via adversarial training
that alternates between FGSM and PGD perturbations while mixing clean and adversarial
samples during optimization. Performance is benchmarked against strong classical baselines
(multinomial logistic regression, random forest, XGBoost), using macro-F1, confusion
matrices, and robustness curves (accuracy vs. ε), alongside latency/energy proxies for edge
feasibility. An optional federated learning (FedAvg) variant accommodates non-IID clients
without centralizing raw data. The Threat model, An evasion adversary perturbs inputs within
an ℓ∞ radius ϵ (small timing/size alterations) at inference time. Poisoning, backdoors, and
model theft are out of scope. The Objective, Maintain high detection fidelity on clean traffic
and graceful degradation under bounded adversarial perturbations, subject to latency/memory
constraints typical of IoT gateways.
Figure 1: System Architecture
Components
Feature Extraction (edge): From flow records: duration, packet/byte counts, TCP flag
counts, protocol IDs; derived rates/ratios (packets/s, bytes/s, mean packet size, interarrival time, SYN/ACK ratios).
Classifier (edge): TinyMLP d→128→64→K with ReLU activations; compact
parameter budget for millisecond-scale inference on CPU-class hardware.
Adversarial Training (training-time): Alternating FGSM/PGD generation with clean–
adversarial mixing per epoch.
Cloud Registry: Versioning, signed model updates, anonymized telemetry.
Federated Coordinator: FedAvg rounds across non-IID clients.
3. Detailed Procedure
A. Data Preparation
1. Ingest flow data (synthetic BoT-IoT-style or public datasets such as CICIDS2017, BoTIoT, ToN_IoT).
2. Select numeric features; sanitize (replace NaN/±∞), remove constants.
3. Engineer derived features:
,
,
,
,
4. Split data with class stratification: train/validation/test === 72%/8%/20%.
5. Standardize features by z-score (fit on training partition only).
B. Baseline Models
6. Train Logistic Regression (multinomial), Random Forest (≈300 trees), and XGBoost
(multi:softprob).
7. Evaluate on clean test data: accuracy, macro-precision/recall, macro-F1; persist
confusion matrices.
C. Proposed Model (TinyMLP + Adversarial Training)
8. Initialize TinyMLP (d → 128 → 64 → K; loss = cross-entropy; optimizer = Adam.
9. Alternate by epoch between FGSM and PGD attacks to generate adversarial
counterparts.
10. Mix clean and adversarial samples (e.g., 1:1) each epoch; update parameters; monitor
validation loss for checkpointing.
D. Robustness & Efficiency Evaluation
11. Proposed (Clean): test on clean inputs.
12. Proposed (FGSM/PGD): test on adversarial inputs across ϵ ∈ {0.005, 0.01, 0.02, 0.03,
0.05}
13. Produce robustness curves (accuracy vs. ε).
14. Measure latency per sample (CPU) and compute energy proxy (latency × parameter
count for neural models).
E. Optional Federated Learning (FedAvg)
15. Partition training data into KKK non-IID shards.
16. For each round: broadcast the global model → clients perform short local training →
aggregate weights (FedAvg).
17. Evaluate global model before and after federated rounds on a held-out test set.
4. Algorithmic Workflow (Step-by-Step)
Input: flow dataset D={(xi,yi)}, class set {0,…,K−1}, attack budget ϵ PGD steps TTT, step
size α.
Output: robust TinyMLP fθf_\thetafθ, baseline models, metrics and figures.
1.
2.
3.
4.
Build XXX from flows; engineer rates/ratios; sanitize and standardize.
Create stratified train/val/test splits.
Fit LR/RF/XGB and evaluate on clean test data.
Initialize TinyMLP and train for EEE epochs:
o If epoch is odd → generate FGSM adversarial samples; else PGD.
o Mix clean and adversarial data; perform one training epoch; track validation
loss; store best checkpoint.
5. Evaluate TinyMLP on clean data and on adversarial test data across ε grid.
6. Plot confusion matrices, macro-F1 bars, and robustness curves; compute latency/energy
metrics.
7. (Optional) Run RRR rounds of FedAvg over non-IID clients and re-evaluate.
5. Pseudocode
5.1 Data Building and Splits
PROCEDURE BUILD_DATASET(raw)
X ← numeric_columns(raw)
X ← replace_nonfinite(X, 0)
X ← drop_constant_features(X)
X ← add_features([pkts_per_sec, bytes_per_sec, mean_pkt_size, iat_mean, syn_ratio,
ack_ratio])
(X_tr, X_te, y_tr, y_te) ← stratified_split(X, y, test=0.20)
(X_tr, X_va, y_tr, y_va) ← stratified_split(X_tr, y_tr, val=0.10)
scaler ← fit_standard_scaler(X_tr)
return scaler(X_tr), scaler(X_va), scaler(X_te), y_tr, y_va, y_te
END
5.2 Adversarial Attacks
FUNCTION FGSM(model, X, y, ε)
g ← ∂/∂X CE(model(X), y)
X_adv ← clip(X + ε * sign(g), bounds)
return X_adv
END
FUNCTION PGD(model, X, y, ε, α, T)
X0 ← X; X_adv ← X
FOR t = 1..T DO
g ← ∂/∂X CE(model(X_adv), y)
X_adv ← X_adv + α * sign(g)
X_adv ← project_Linf(X_adv, center=X0, radius=ε)
X_adv ← clip(X_adv, bounds)
END FOR
return X_adv
END
5.3 Proposed Training (Alternating FGSM/PGD)
PROCEDURE TRAIN_TINYMLP_ADV(Xtr, ytr, Xva, yva, E, ε, α, T, ratio)
θ ← init_TinyMLP(d_in=dim(Xtr), K)
best_loss ← +∞; θ_best ← θ
FOR e = 1..E DO
if e is odd then X_adv ← FGSM(θ, Xtr, ytr, ε)
else
X_adv ← PGD(θ, Xtr, ytr, ε, α, T)
X_mix, y_mix ← MIX(Xtr, ytr, X_adv, ytr, ratio) // e.g., 1:1
θ ← one_epoch_train(θ, X_mix, y_mix, Adam, CE)
ℓ_val ← CE(θ(Xva), yva)
if ℓ_val < best_loss then best_loss ← ℓ_val; θ_best ← copy(θ)
END FOR
return θ_best
END
5.4 Robustness Evaluation
PROCEDURE ROBUSTNESS_CURVES(model, Xte, yte, eps_list)
results ← {}
FOR ε in eps_list DO
acc_fgsm ← ACC(yte, argmax(model(FGSM(model, Xte, yte, ε))))
acc_pgd ← ACC(yte, argmax(model(PGD(model, Xte, yte, ε, α=ε/4, T=10))))
results[ε] ← (acc_fgsm, acc_pgd)
END FOR
return results
END
6. Design Rationale
Flow-rate/ratio features stabilize behavior across benign load changes and emphasize
temporal and control-plane dynamics (e.g., SYN storms).
TinyMLP (128–64) balances representational capacity with strict runtime and memory
budgets, enabling CPU-only edge inference and compatibility with
quantization/pruning.
Alternating FGSM/PGD provides complementary gradient exposures—single-step and
iterative—producing smoother decision boundaries and improved resistance to firstorder evasion within the specified budget.
Clean–adversarial mixing preserves clean-data performance while hardening
robustness.
Macro-F1 serves as the primary metric to counter class imbalance; robustness curves
enable direct comparison across ε settings.
Latency/energy proxies reflect deployment reality and support engineering decisions
beyond accuracy.
7. Default Hyperparameters
Scaler: Standardization (mean 0, std 1).
TinyMLP: hidden sizes [128,64][128, 64][128,64], activation ReLU; output softmax
over KKK.
Optimizer: Adam, learning rate 1×103, batch size 512.
Adversarial training: epochs 10–20; ϵ=0.02 (standardized space); PGD steps = 10; step
size α=ϵ/4; clean:adv mixing =1:1=1:1=1:1.
Baselines: LR (max_iter=400), RF (300 trees), XGB (depth 7, 350 trees, hist).
Robustness grid: {0.0,0.005,0.01,0.02,0.03,0.5}
8. Computational Profile
Inference (TinyMLP): O(d⋅128+128⋅64+64⋅K) MACs per sample; typically submillisecond on x86/ARM microservers for d<100, K≤10.
Training: Comparable to a small MLP plus adversarial generation cost (FGSM ≈ 1
backprop; PGD ≈ TTT steps).
Memory: Parameter count ≈d⋅128+128⋅64+64⋅K (+ biases), often <100k weights.
Federated communication: Weight exchanges only; low bandwidth overhead for
TinyMLP.
6. Results and Discussion
6.1 Experimental Setup
Evaluation considers two settings: (i) a BoT-IoT–style multi-class simulator producing
Normal, DoS, DDoS, PortScan, and Exfiltration flows; and (ii) optional public datasets
(CICIDS2017, BoT-IoT, ToN_IoT) loaded without pipeline changes. Data are stratified into
train/validation/test (72/8/20). Features include raw flow counts and derived rate/ratio signals.
Baselines comprise multinomial Logistic Regression (LR), Random Forest (RF), and XGBoost
(XGB). The proposed classifier is a compact TinyMLP trained with alternating FGSM/PGD
adversarial batches. Primary metric is macro-F1, with accuracy, macro-precision/recall and
confusion matrices as secondary diagnostics. Robustness is assessed via accuracy–vs–ε curves
under FGSM/PGD. Edge feasibility is characterized by per-sample CPU latency and a simple
energy proxy (latency × parameter count for neural models).
6.2 Overall Performance on Clean Traffic
Across clean test sets, the TinyMLP achieves macro-F1 that is competitive with strong classical
baselines while preserving a substantially smaller parameter budget. Performance parity with
XGBoost is typically observed on classes exhibiting stable temporal patterns (e.g., Normal,
PortScan), whereas RF may retain advantages on highly irregular bursts if feature interactions
dominate. The confusion matrix for the proposed model (Fig. “cm_prop_clean.png”) indicates
confident separation for Normal traffic and PortScan, with the majority of residual errors
concentrated among attack families sharing rate-based signatures (DoS vs. DDoS). This aligns
with the role of flow-rate/ratio features in emphasizing temporal intensity and control
dynamics.
Interpretation. Clean-set outcomes indicate that a lightweight architecture can provide nearstate-of-the-art detection under edge constraints, provided that rate/ratio features are included
and standardization is applied consistently.
6.3 Robustness Under Adversarial Perturbations
Robustness curves (Fig. “robustness_curves.png”) demonstrate a shallower accuracy decay for
the adversarially trained TinyMLP relative to baselines when ε increases under FGSM and
PGD. Classical models tend to exhibit sharper inflection points, reflecting vulnerability to
small yet structured perturbations in standardized feature space. The proposed model maintains
higher accuracy for modest ε (e.g., 0.005–0.02) and degrades more gracefully thereafter,
indicating effective hardening of decision boundaries.
Interpretation. Alternating FGSM/PGD training, together with mixed clean/adversarial
batches, yields improved worst-case behavior without materially sacrificing clean accuracy.
6.4 Error Analysis
Confusion matrices across models reveal consistent difficulty in separating DoS and DDoS at
the margin, which is expected given similar burst dynamics. Derived ratios (pkts/s, bytes/s,
SYN/ACK) reduce, but do not eliminate, these confusions. Misclassifications between
Exfiltration and Normal primarily occur at low-rate regimes when payload volume is spread
over longer durations; rate features mitigate this effect by emphasizing bytes/s and mean packet
size.
Implication. Additional timing descriptors (e.g., fine-grained inter-arrival variance) or
lightweight sequence cues could further disambiguate adjacent classes while keeping inference
budgets tight.
6.5 Edge Feasibility: Latency and Energy Proxy
Latency measurements (Fig. “latency_per_sample.png”; table printed in the notebook) show
sub-millisecond to low-millisecond inference per sample for TinyMLP on CPU-class
hardware, with a model size suitable for gateways and microservers. The energy proxy (latency
× parameter count) indicates a favorable profile compared to larger neural architectures, and
competitive or better throughput than tree ensembles when batch prediction is considered.
Implication. The classifier satisfies typical gateway budgets for online flow scoring and fits
within memory footprints compatible with containerized or on-device deployment.
6.6 Federated Learning
In a toy non-IID setting, several rounds of FedAvg yield measurable recovery of macro-F1
relative to an unfederated initialization, suggesting that privacy-preserving updates are feasible
without centralizing raw traffic. While the effect size depends on client skew and local epochs,
the trend supports practical adaptation paths in multi-tenant environments.
6.7 Ablations and Sensitivity
Adversarial strength (ε). Moderate ε (e.g., 0.01–0.02 in standardized space) offers a
favorable clean/robust trade-off; excessively large ε degrades clean performance.
Model capacity. Enlarging hidden layers improves clean macro-F1 but increases
latency; the 128–64 configuration balances these costs for edge deployments.
Feature ablation. Removing rate/ratio features consistently reduces both clean and
robust macro-F1, confirming their utility for temporal discrimination.
REFFFFYYY
Confusion matrices:
i)
iii)
cm_lr.png
cm_xgb.png
ii)
cm_rf.png
iv) cm_prop_clean.png
Robustness curves:
All figures referenced above are generated by the notebook and saved to /content/outputs/:
Confusion matrices: cm_lr.png, cm_rf.png, cm_xgb.png, cm_prop_clean.png
Robustness curves: robustness_curves.png
Macro-F1 comparison: macro_f1_bars.png
Latency
chart:
latency_per_sample.png
Aggregated metrics are saved in results_summary.csv for insertion into tables.
7. Conclusion and Future Scope
A lightweight, edge-aware intrusion detection scheme that combines a compact TinyMLP with
alternating FGSM/PGD adversarial training demonstrates a practical balance of accuracy,
robustness, and efficiency for AI-driven IoT networks. Using flow-centric rate/ratio features
and standardized preprocessing, the approach attains competitive macro-F1 on clean traffic
while degrading more gracefully under bounded evasion, and its small parameter budget with
low per-sample latency indicates suitability for gateways and microservers; an optional
federated variant further outlines an adaptation path for non-IID settings without centralizing
raw data. Future work should extend robustness beyond ℓ∞\ell_\inftyℓ∞ constraints toward
protocol- and semantics-aware attacks/defenses and pursue certified guarantees via
randomized smoothing or Lipschitz-controlled architectures; incorporate sequence-aware yet
lightweight temporal encoders to capture micro-timing; and realize deployment-grade
optimization through quantization, pruning, operator fusion, and measurements on
x86/ARM/RISC-V with true energy instrumentation. End-to-end validation on pcap-to-flow
pipelines (eBPF/XDP) and production-like replay testbeds, alongside continual and federated
learning with secure aggregation and differential privacy, will strengthen reliability under drift
and privacy constraints. Finally, integrating compact post-hoc explanations for operator triage,
evaluating cross-dataset generalization and domain adaptation, and coupling detection with
automated policy responses (e.g., rate limiting, quarantine) represent high-impact steps toward
robust, operational IoT cyber defense.
8.References
[1] J. Azimjonov et al.
Stochastic gradient descent classifier-based lightweight intrusion detection systems using
the efficient feature subsets of datasets
Expert Systems with Applications (2024)
[2] Abd ElazizM.
Intrusion detection approach for cloud and IoT environments using deep learning and
capuchin search algorithm
Advances in Engineering Software (2023)
[3] A. Srivastava et al.
FP-growth-based signature extraction and unknown variants of DoS/DDoS attack
detection on real-time data stream
Journal of Information Security and Applications (2025)
[4] H. Setia et al.
Securing the road ahead: Machine learning-driven ddos attack detection in vanet cloud
environments
Cyber Security and Applications (2024)
0
You can add this document to your study collection(s)
Sign in Available only to authorized usersYou can add this document to your saved list
Sign in Available only to authorized users(For complaints, use another form )