💻 computer science

TITAN: Three-Tier Intrusion-Detection Tree-Based Adaptive Network for Industrial Internet of Things

TITAN is a novel three-tier federated learning architecture for Industrial IoT intrusion detection that overcomes non-IID data and class imbalance challenges by exchanging only prediction outputs and device summaries via adaptive knowledge distillation and Bayesian aggregation, achieving superior macro-F1 performance over existing methods without requiring raw data or gradient sharing.

Original authors: Sandeep Ghosh, Mohammed Al-Khafajiy, Saeid Pourroostaei Ardakani Ardakani

Published 2026-07-09

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Sandeep Ghosh, Mohammed Al-Khafajiy, Saeid Pourroostaei Ardakani Ardakani

Original paper licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a massive, high-security industrial complex (like a smart factory or a power grid) filled with thousands of different devices: cameras, sensors, smart locks, and robots. Each of these devices is constantly watching for hackers trying to break in.

The problem is that no single device sees the whole picture. One camera might only see "DoS" attacks (flooding the network), while a sensor only sees "brute-force" password attacks. Also, the bad guys are rare; 99% of the traffic is normal, and the attacks are tiny needles in a haystack.

If you try to build one giant "super-brain" by sending all the raw data to a central server, you hit two walls:

Privacy: You can't send private data out of the factory.
Bias: If you just average the opinions of all devices, the "super-brain" will ignore the rare attacks because the "normal" traffic drowns them out.

TITAN is a new system designed to solve this. Think of it as a three-tier detective agency that solves crimes without ever sharing the actual crime scene photos.

The Three Tiers (The Detective Agency)

Tier 1: The Local Detectives (The Devices)
Each device trains its own "detective" (a specialized AI model) using only its own local data.

The Challenge: Because a device only sees a few types of attacks, its detective might be an expert at spotting "DoS" but completely blind to "Brute-force."
The Fix: TITAN uses a special training routine. It forces the local detective to pay extra attention to the rare clues it does see, and it even gives the detective a tiny "hint" about the types of crimes it hasn't seen yet, so it doesn't forget they exist.
The Output: The device doesn't send its raw data or its internal brain structure. It only sends a report card: "I think there is a 90% chance this is a DoS attack, 5% Brute-force, and 5% Normal."

Tier 2: The Regional Managers (The Edge Servers)
These managers sit between the devices and the central HQ. They collect the "report cards" from a group of devices.

The Challenge: If you just average the reports, you lose the specialist knowledge.
The Fix: The manager acts like a smart editor. It learns which devices are experts in which areas. If Device A is great at spotting "DoS" but Device B is great at "Brute-force," the manager weights their opinions accordingly. It uses a "knowledge distillation" technique, which is like a senior detective teaching a junior one how to interpret the clues without revealing the original crime scene.
The Output: A refined, regional summary report.

Tier 3: The Global Chief (The Central Server)
The Chief receives reports from all the Regional Managers.

The Challenge: The managers might disagree. One says "It's a DoS," another says "It's Normal."
The Fix: TITAN uses a Bayesian "Product of Experts" approach. Imagine a jury. If one expert says, "I am 100% sure this is not a Brute-force attack," the Chief listens. But if an expert has never seen a Brute-force attack before, the Chief ignores their opinion on that specific topic (silencing the "veto" of an uninformed expert).
The Rescue Team: If a rare attack is so rare that no single region is sure about it, a special "Expert Panel" (the top 5 devices that have seen that specific attack before) is called in to vote.
The Calibration: Finally, the Chief runs the final verdict through a "truth filter." This ensures the system isn't just guessing; it makes sure that when it says "90% chance," it really means 90%. This is crucial so the factory doesn't get flooded with false alarms.

Why is TITAN Better?

The paper tested TITAN against the standard method (called FedAvg, which is like a simple "average of all opinions").

The Result: TITAN was significantly better at catching the rare, dangerous attacks.
The Analogy: If FedAvg is like asking 20 people to guess the answer to a trivia question and taking the average, TITAN is like asking 20 specialists, letting them debate, and then having a judge weigh their answers based on who is actually an expert in that specific topic.
The Numbers: TITAN improved the detection of rare attacks by 6.2% on average, and by up to 23.3% in the most difficult, chaotic scenarios. It even outperformed a "perfect oracle" (a hypothetical system that knows the best single device's performance) in most cases.

The Bottom Line

TITAN is a system that lets industrial devices work together to spot hackers without sharing private data. It solves the problem of "rare attacks" by treating them as a calibration issue and using a smart, three-layer voting system that respects the unique expertise of every single device. It's not just about averaging opinions; it's about knowing who to trust for what specific threat.

Technical Summary: TITAN – Three-Tier Intrusion-Detection Tree-Based Adaptive Network

1. Problem Statement

The paper addresses two critical, compounding challenges in Federated Learning (FL) for Industrial Internet of Things (IIoT) intrusion detection:

Severe Non-IID Partitioning: In IIoT environments, individual devices observe disjoint slices of attack traffic. Entire attack classes may be absent from specific devices, violating the independent and identically distributed (IID) assumption standard FL relies on.
Extreme Class Imbalance: Operational attack classes (e.g., web attacks, brute-force) are often rare, comprising less than 0.1% of samples, while dominant flows (DoS/DDoS) can exceed 94%.

Existing solutions fail to address the intersection of these issues. Parameter-space methods (e.g., FedAvg, FedProx) assume differentiable models (neural networks), excluding efficient tree-based learners like LightGBM which excel on tabular flow data. Furthermore, these methods often average weights in a way that dilutes minority-class expertise, leading to miscalibrated global models that sacrifice recall for majority-class accuracy. Prediction-level methods often require a shared public dataset for knowledge distillation, which conflicts with IIoT data-minimization and residency regulations.

2. Methodology: The TITAN Architecture

TITAN (Three-Tier Intrusion-Detection Tree-Based Adaptive Network) is a hierarchical federated architecture that exchanges only prediction outputs and small summary statistics, never raw data, gradients, or model parameters. It is designed specifically for non-differentiable, tree-based learners.

Tier 1: Device-Level Training

Each device ( $D=20$ ) trains an independent LightGBM classifier on its local non-IID data through a four-phase adaptive boosting schedule:

Phase 1 (Balanced Base): Trains with class-balanced weights.
Phase 2 (Hard-Sample Refinement): Uses an adaptive focal loss exponent derived from Phase 1's F1 scores to focus on hard samples without overwriting majority boundaries.
Phase 3 (Per-Class Rebalancing): Conditionally rebalances classes with low F1 scores, provided they meet a minimum sample count guard to prevent overfitting on singletons.
Phase 4 (Minority Enrichment): Downsamples the dominant class to a ratio relative to the second-largest class while retaining all minority samples, allowing the model to form leaf nodes for rare classes.

Following RAW training, a META model is trained using an out-of-fold (OOF) design. It takes the RAW model's predictions on a held-out partition as input features. This prevents the "degenerate teacher" problem where a model predicts near-perfectly on its own training data. The device communicates only these META probability vectors ( $K$ -class outputs) and small label summaries to the edge.

Tier 2: Edge-Level Knowledge-Distilled Ensemble

Devices are grouped into edge clusters ( $E=5$ ). Each edge trains a LightGBM ensemble that learns to trust specific devices for specific classes.

Adaptive Knowledge Distillation (KD): The edge uses a self-contained, $k$ -fold OOF teacher built from its own member devices' META outputs to generate soft labels.
Gating Mechanisms: To prevent unreliable teachers from corrupting the student, four multiplicative gates modulate the KD signal:
1. Entropy Gate: Suppresses KD if the teacher is over-confident (near-one-hot).
2. Support Gate: Disables KD for classes absent from the edge's local labels.
3. Recall Gate: Scales KD based on the teacher's per-class recall.
4. Class-Frequency Gate: Prevents majority bias from diluting minority class learning.
Aggregation: At evaluation, the edge aggregates device outputs using static expertise weights (based on training sample counts) and dynamic confidence weights.

Tier 3: Global Bayesian Fusion

The global tier fuses predictions from the five edges using a Bayesian Product-of-Experts (PoE) framework.

Expertise Masking: A per-class expertise mask ( $m_{e,k}$ ) silences edges that lack training support for a specific class, preventing uninformed experts from casting "confident near-zero" vetoes that would suppress rare classes.
Rare-Class Rescue (Expert Panel): If the Bayesian fusion fails to assign a majority probability to a rare class (or the class is globally rare), an "Expert Panel" of the top 5 devices (ranked by local expertise) votes to rescue the signal.
Safety-Gated Calibration: A three-stage calibration pipeline refines the final probabilities:
1. Temperature Scaling.
2. Meta-learner Blending (stacking edge outputs).
3. Per-class log-odds bias fitting.
  Crucially, each stage is "safety-gated" on macro-F1; if a step does not improve macro-F1, the system reverts to the upstream value.

3. Key Contributions

Prediction-Level Federation for Tree-Based Learners: TITAN enables federated learning for LightGBM without a shared public dataset. It replaces parameter averaging with prediction-space exchange, using an OOF teacher to generate soft targets locally, thereby adhering to data-minimization rules.
Per-Class Expertise Gating: The architecture introduces a per-(edge, class) expertise mask in the Bayesian fusion layer. This allows the system to silence uninformed experts on specific classes, a mechanism necessary for federations where entire classes are absent from certain partitions.
Safety-Gated Multi-Stage Calibration: Unlike prior work that optimizes for calibration metrics (like ECE) in isolation, TITAN integrates calibration into the federated pipeline with a safety gate driven by macro-F1. This ensures that calibration adjustments do not degrade the detection of minority classes.
Rigorous Evaluation Protocol: The paper establishes a reproducible protocol across 16 configurations (4 datasets $\times$ 2 non-IID severities $\times$ 2 grouping strategies) with strict row-level deduplication to prevent accuracy inflation.

4. Experimental Results

Evaluated on four IoT benchmarks (CIC IoT-DIAD 2024, CIC IoT 2023, NF-BoT-IoT-V3, NF-ToN-IoT-V3) under strict non-IID conditions ( $\alpha=0.1$ ):

Performance vs. Baselines: TITAN outperforms Federated Averaging (FedAvg) by a mean of 6.2 percentage points in macro-F1 across all configurations.
Non-IID Severity: The performance gap widens with data heterogeneity. On the most heterogeneous splits, TITAN exceeds FedAvg by 23.3 percentage points.
Oracle Comparison: TITAN exceeds the "Best-Device Oracle" (the best single local model) in 14 of 16 configurations and surpasses a centralized ceiling in 11 configurations.
Source of Gain: The paper notes that the gains are driven primarily by calibration improvements rather than raw discrimination power, highlighting the importance of the calibration pipeline in handling class imbalance.
Failure of Alternatives: The study observes that FedProx fails to improve over FedAvg on tree-based learners and that single-metric evaluations (accuracy) hide severe minority-class failures (the "accuracy paradox").

5. Significance and Claims

The paper claims that TITAN provides a viable path for federated intrusion detection in IIoT where data residency, extreme imbalance, and non-IID distributions prevent the use of standard parameter-averaging FL.

Architectural Novelty: It is the first federated IDS to combine tree-based learners, no shared dataset, per-class expertise gating, and macro-F1-gated calibration in a single framework.
Operational Relevance: By focusing on macro-F1 and calibration, TITAN addresses the "base-rate fallacy" where high accuracy masks the failure to detect rare, critical attacks.
Scalability: The architecture supports heterogeneous partitions ranging from 28 to over 2 million samples per device, demonstrating robustness across varying data scales.

The authors position TITAN not merely as a performance improvement, but as a necessary evolution of FL for tabular, high-stakes industrial security where standard neural-network-centric approaches are computationally inefficient or statistically unsound.