Trust-Aware-Federated-Learning-for-Network-Intrusion-Detection

KO | EN

gitlite — search

#javascript #python #hacktoberfest #ai #llm #golang #android #rust #deep-learning #docker #windows #kubernetes #pytorch #openai

Trust-Aware-Federated-Learning-for-Network-Intrusion-Detection

(★ 15)

This project implements a Trust-Aware Federated Intrusion Detection System using CICIDS-2017. It combines a dual-head autoencoder with Federated Learning for data privacy. An A/R/C trust mechanism prevents poisoning attacks by filtering malicious clients, while evaluation on zero-day threats ensures robust real-world generalization.

Trust-Aware-Federated-Learning-for-Network-Intrusion-Detection 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# 🛡️ Trust-Aware Federated Learning for Network Intrusion Detection

### Detecting Cyber Attacks — Including Unseen Zero-Day Threats — Without Centralising Data

<br/>

![Python](https://img.shields.io/badge/Python-3.11-3776AB?style=for-the-badge&logo=python&logoColor=white)
![TensorFlow](https://img.shields.io/badge/TensorFlow-2.15.0-FF6F00?style=for-the-badge&logo=tensorflow&logoColor=white)
![Keras](https://img.shields.io/badge/Keras-2.15-D00000?style=for-the-badge&logo=keras&logoColor=white)
![scikit-learn](https://img.shields.io/badge/scikit--learn-1.3.2-F7931E?style=for-the-badge&logo=scikit-learn&logoColor=white)
![Platform](https://img.shields.io/badge/Platform-Kaggle-20BEFF?style=for-the-badge&logo=kaggle&logoColor=white)
![License](https://img.shields.io/badge/License-MIT-green?style=for-the-badge)

<br/>

> **A privacy-preserving intrusion detection system built with Federated Learning, a Dual-Head Autoencoder, and a lightweight A/R/C trust gating mechanism — evaluated on the CICIDS-2017 benchmark including zero-day and poisoning attack scenarios.**

</div>

---

## 📋 Table of Contents

- [Overview](#-overview)
- [Architecture](#-architecture)
- [Dataset](#-dataset--cicids-2017)
- [Key Components](#-key-components)
  - [Dual-Head Autoencoder](#1-dual-head-autoencoder)
  - [Federated Learning Pipeline](#2-federated-learning-pipeline)
  - [A/R/C Trust Mechanism](#3-arc-trust-mechanism)
  - [Zero-Day Detection](#4-zero-day-detection)
  - [Poisoning Attack Defence](#5-poisoning-attack-defence)
- [Notebook Structure](#-notebook-structure)
- [Results & Evaluation](#-results--evaluation)
- [Getting Started](#-getting-started)
- [File Structure](#-file-structure)
- [Citation](#-citation)

---

## 🔭 Overview

Traditional Intrusion Detection Systems (IDS) require centralising raw network traffic logs to a single server for model training — a serious **privacy and compliance risk** for organisations sharing sensitive infrastructure data.

This project proposes a **Trust-Aware Federated IDS** that:

- 🔒 **Keeps data local** — each client (network node / organisation) trains on its own private traffic shard; only model weights are shared
- 🧠 **Detects both known and unknown attacks** — a dual-head autoencoder combines supervised classification with unsupervised reconstruction error, enabling detection of zero-day threats never seen during training
- 🛡️ **Resists poisoning** — an A/R/C trust gate filters malicious or unreliable clients before each federated aggregation round
- 📊 **Evaluates rigorously** — four attack classes are completely withheld from training as a zero-day holdout; three poisoning schemes are tested with Trust ON vs Trust OFF

---

## 🏗️ Architecture

### System Overview

```mermaid
flowchart TD
    DS["🗄️ CICIDS-2017 Dataset\n8 CSV Files · ~2.5M flows · 15 classes"]

subgraph PRE["🔧 Preprocessing Pipeline"]
        direction LR
        L["Load & Clean"] --> E["Label Encode"] --> S["MinMax / Standard Scale"] --> SM["SMOTE\nRare class oversampling"]
    end

subgraph ZD["🎯 Zero-Day Protocol"]
        ZDS["Heartbleed · Infiltration\nSQL Injection · XSS\n── held out completely ──"]
    end

DS --> PRE
    DS --> ZD

subgraph FL["🤝 Federated Learning  (K=5 clients · 8 rounds)"]
        direction TB
        G["🌐 Global Model\nDual Autoencoder"]
        C1["Client 1"] & C2["Client 2"] & C3["Client 3"] & C4["Client 4"] & C5["Client 5"]
        G -->|"broadcast weights"| C1 & C2 & C3 & C4 & C5
        C1 & C2 & C3 & C4 & C5 -->|"local updates"| TRUST
        TRUST["⚖️ A/R/C Trust Gate\nFilter low-trust clients"]
        TRUST -->|"FedAvg on accepted"| G
    end

PRE -->|"Dirichlet non-IID split"| FL

subgraph EVAL["📊 Evaluation"]
        E1["Seen-attack\nTest Set"]
        E2["Zero-Day\nMixed Set"]
        E3["Poisoning\nExperiments"]
    end

FL --> EVAL
    ZD --> E2
```

---

### Dual Autoencoder Architecture

```mermaid
graph LR
    IN["Input\n63 features"]

subgraph ENC["Encoder"]
        D64["Dense 64 · ReLU"]
        D32["Dense 32 · ReLU"]
        BN["Dense 16 · ReLU\n── bottleneck z ──"]
    end

subgraph CLF["Classifier Head"]
        C1["Dense 1 · Sigmoid\n→ P(attack)"]
    end

subgraph DEC["Decoder"]
        D32b["Dense 32 · ReLU"]
        D64b["Dense 64 · ReLU"]
        RECON["Dense 63 · Linear\n→ X̂ (reconstruction)"]
    end

IN --> D64 --> D32 --> BN
    BN --> C1
    BN --> D32b --> D64b --> RECON

style BN fill:#ff9800,color:#000
    style C1 fill:#4caf50,color:#fff
    style RECON fill:#2196f3,color:#fff
```

**Combined Loss Function:**

$$\mathcal{L} = \lambda \cdot \underbrace{\text{MSE}(X, \hat{X})}_{\text{Reconstruction}} + (1 - \lambda) \cdot \underbrace{\text{BCE}(y, \hat{y})}_{\text{Classification}}$$

| λ value | Effect |
|---|---|
| `λ → 1.0` | Prioritises reconstruction → better zero-day recall |
| `λ = 0.5` | Balanced (default) |
| `λ → 0.0` | Prioritises classification → better supervised F1 |

---

### Federated Learning Round

```mermaid
sequenceDiagram
    participant G  as 🌐 Global Server
    participant C1 as Client 1
    participant C2 as Client 2
    participant CN as Client N
    participant T  as ⚖️ Trust Gate

loop Each FL Round
        G  ->> C1: Broadcast global weights W_g
        G  ->> C2: Broadcast global weights W_g
        G  ->> CN: Broadcast global weights W_g

C1 ->> C1: Local training (1 epoch, batch=1024)
        C2 ->> C2: Local training (1 epoch, batch=1024)
        CN ->> CN: Local training (1 epoch, batch=1024)

C1 ->> T: Submit W_1, val_acc, recon_MSE
        C2 ->> T: Submit W_2, val_acc, recon_MSE
        CN ->> T: Submit W_N, val_acc, recon_MSE

T  ->> T: Compute A·α + R·β + C·γ per client
        T  ->> T: Reject clients where T < τ=0.60

T  ->> G: Accepted weight updates only
        G  ->> G: FedAvg (weighted by dataset size)
    end
```

---

## 📦 Dataset — CICIDS-2017

The **Canadian Institute for Cybersecurity Intrusion Detection System 2017** dataset contains network flow records captured over five days across a realistic topology.

| Property | Value |
|---|---|
| **Source** | [Kaggle — Network Intrusion Dataset](https://www.kaggle.com/datasets/chethuhn/network-intrusion-dataset) |
| **Total samples** | ~2.5 million (after deduplication) |
| **Features** | 63 numeric flow statistics |
| **Traffic classes** | 15 (1 benign + 14 attack types) |
| **Majority class** | BENIGN (~83%) |
| **Rarest class** | Heartbleed (11 samples) |
| **Capture period** | Monday – Friday, July 3–7 2017 |

### Class Distribution

```
BENIGN                    ████████████████████████████████████  2,096,484
DoS_Hulk                  ████                                     172,849
DDoS                      ███                                      128,016
PortScan                  ██                                        90,819
DoS_GoldenEye             ▌                                         10,286
FTP_Patator               ▎                                          5,933
DoS_slowloris             ▎                                          5,385
DoS_Slowhttptest          ▎                                          5,228
SSH_Patator               ▏                                          3,219
Bot                       ▏                                          1,953
Web_Attack_BruteForce     ▏                                          1,470
Web_Attack_XSS            ▏   ← zero-day                              652
Infiltration              ▏   ← zero-day                               36
Web_Attack_SQL_Injection  ▏   ← zero-day                               21
Heartbleed                ▏   ← zero-day                               11
```

### Zero-Day Holdout Protocol

Four classes are **completely excluded from training** to simulate novel, unseen attack types:

```mermaid
graph LR
    FD["Full Dataset\n~2.5M samples"]

FD --> TP["Training Pool\nBENIGN + 10 seen attacks"]
    FD --> ZD["Zero-Day Slice 🔒\nHeartbleed · Infiltration\nSQL Injection · XSS"]

TP --> TR["80% Train"]
    TP --> VA["10% Val"]
    TP --> TE["10% Test\n(seen attacks only)"]

ZD --> ZDE["Held-out Evaluation\n(test time only)"]

style ZD fill:#f44336,color:#fff
    style ZDE fill:#f44336,color:#fff
```

---

## 🔑 Key Components

### 1. Dual-Head Autoencoder

The model uses a shared encoder bottleneck that simultaneously serves two objectives:

- **Reconstruction head** — learns the distribution of *normal* traffic. Anomalous (zero-day) traffic produces a high reconstruction MSE even without a label, providing an unsupervised anomaly signal.
- **Classification head** — a sigmoid output trained with Binary Cross-Entropy on the *seen* attack classes.

At inference time, a **fusion score** combines both signals:

```
score = λ · P(attack) + (1 − λ) · MSE_normalised
```

The optimal `λ` and decision threshold `τ` are found by grid search on the PR curve, maximising F1.

---

### 2. Federated Learning Pipeline

| Component | Detail |
|---|---|
| **Algorithm** | FedAvg (weighted by client dataset size) |
| **Clients** | K = 5 |
| **Rounds** | 8 |
| **Local epochs** | 1 per round |
| **Batch size** | 1,024 |
| **Data heterogeneity** | Dirichlet(α=0.5) non-IID split |
| **Class weighting** | Per-client balanced class weights, clipped at 10× |

#### Non-IID Client Partitioning (Dirichlet)

```mermaid
graph TD
    TD["Training Data"] --> DIR["Dirichlet(α) Sampler"]

DIR --> CL1["Client 1\npredominantly DoS traffic"]
    DIR --> CL2["Client 2\nmixed benign + PortScan"]
    DIR --> CL3["Client 3\npredominantly BENIGN"]
    DIR --> CL4["Client 4\nmixed attack types"]
    DIR --> CL5["Client 5\npredominantly Brute Force"]

style CL1 fill:#1565c0,color:#fff
    style CL2 fill:#2e7d32,color:#fff
    style CL3 fill:#558b2f,color:#fff
    style CL4 fill:#6a1b9a,color:#fff
    style CL5 fill:#ad1457,color:#fff
```

| α (Dirichlet) | Data distribution |
|---|---|
| 0.1 | Highly non-IID — each client sees ~1 class |
| **0.5** | **Moderate non-IID — default setting** |
| 10.0 | Near-IID — each client is representative |

---

### 3. A/R/C Trust Mechanism

After each local training round, the global server scores every client on three dimensions before aggregation:

```mermaid
graph TD
    subgraph SIGNALS["Per-Client Signals"]
        A["A — Accuracy\nValidation accuracy of local model\n↑ higher = more trusted"]
        R["R — Reconstruction\nValidation recon MSE\n↓ lower = more trusted"]
        C["C — Cosine Distance\nL₂ dist of weights from global\n↓ lower = more trusted"]
    end

A --> NORM["Normalise each signal\nto 0–1"]
    R --> NORM
    C --> NORM

NORM --> SCORE["T = α·A_norm + β·R_norm + γ·C_norm\nα=0.4  β=0.3  γ=0.3"]

SCORE --> GATE{"T ≥ τ = 0.60?"}
    GATE -->|"Yes"| ACC["✅ Accepted\nIncluded in FedAvg"]
    GATE -->|"No"| REJ["❌ Rejected\nExcluded this round"]
```

---

### 4. Zero-Day Detection

The system supports two detection strategies at inference time:

| Strategy | Method | Advantage |
|---|---|---|
| **Classifier-only** | Threshold τ* tuned on PR curve | Simple to deploy |
| **Fusion score** | Grid search over λ and τ on mixed zero-day set | Higher recall on unseen attacks |

**Confusion Matrix Interpretation:**

|  | Predicted Benign | Predicted Attack |
|---|---|---|
| **Actually Benign** | ✅ True Negative (TN) | ⚠️ False Positive (FP) |
| **Actually Attack** | ❌ **False Negative (FN)** | ✅ True Positive (TP) |

> In a security context, **False Negatives are the most costly error** — a missed attack can result in a breach. The threshold is therefore tuned to maximise **F1 score** rather than accuracy.

---

### 5. Poisoning Attack Defence

Three poisoning strategies are simulated on a subset of clients:

```mermaid
graph LR
    subgraph ATTACKS["☠️ Poisoning Schemes"]
        LF["Label Flip\nFlip 35% of labels\n0→1 or 1→0"]
        FN["Feature Noise\nAdd Gaussian noise\n(μ=0, σ=3.5) to 35% of rows"]
        BD["Backdoor\nEmbed trigger pattern\nin 6% of samples\n→ relabel as Benign"]
    end

subgraph EXPS["📊 Experiments"]
        E1["EXP 1: Clean + Trust ON\n(baseline ceiling)"]
        E2["EXP 2: Poisoned + Trust OFF\n(measure damage)"]
        E3["EXP 3: Poisoned + Trust ON\n(measure defence)"]
    end

ATTACKS --> E2
    ATTACKS --> E3
```

**Expected outcome:** A poisoned client will exhibit:
- 📉 Low validation accuracy → low **A** score
- 📈 High reconstruction error → low **R** score  
- 📏 Large weight deviation from global → low **C** score

All three signals push the trust score **T** below the acceptance threshold **τ**, causing the client to be filtered out automatically.

---

## 📓 Notebook Structure

```
federated-learning-for-network-intrusion-detection.ipynb
│
├── ⚙️  Section 1 — Environment Setup
│   ├── Pin scikit-learn==1.3.2 & imbalanced-learn==0.11.0
│   └── Install TensorFlow==2.15.0 + tensorflow-io==0.34.0
│
├── 🔍  Part I — Exploratory Data Analysis & Preprocessing
│   ├── 2.1  Data Loading & Cleaning (8 CSV → 1 DataFrame)
│   ├── 2.2  Label Encoding (binary + 15-class)
│   ├── 2.3  Feature Engineering, MinMax Scaling & 70/30 Split
│   ├── 2.4  SMOTE oversampling for 3 rarest classes → 5,000 each
│   └── 2.5  EDA visualisations (distribution, heatmap, pairplot)
│
├── 🏗️  Part II — Federated Learning Architecture
│   ├── 3.1  Hardened data pipeline (UTF-8 sanitisation, constant-col removal)
│   ├── 3.2  Zero-day holdout protocol + Parquet artifact persistence
│   ├── 3.3  TF 2.15 environment (clean install)
│   └── 3.4  Dirichlet client partitioning + class weights + tf.data Datasets
│
├── 🧠  Part III — Trust-Aware FL Training
│   ├── 4.0  Dual autoencoder build & compile
│   ├── 4.1  FL training loop (8 rounds × 5 clients)
│   ├── 4.2  A/R/C trust scoring & client filtering per round
│   ├── 4.3  Round-end evaluation (val / test / zero-day)
│   ├── 4.4  Fusion score grid search (λ × τ)
│   └── 4.5  Zero-day confusion matrices (classifier-only vs fusion)
│
├── ☠️  Part IV — Poisoning Attack Experiments
│   ├── 5.1  Poisoning utilities (label flip, feature noise, backdoor)
│   ├── 5.2  EXP 1: Clean + Trust ON
│   ├── 5.3  EXP 2: Poisoned + Trust OFF
│   ├── 5.4  EXP 3: Poisoned + Trust ON
│   └── 5.5  Summary comparison table
│
└── 🏁  Conclusion & Key Takeaways
```

---

## 📊 Results & Evaluation

### Metrics Tracked Per Round

| Metric | Description |
|---|---|
| `val_auroc` / `test_auroc` | Area Under the ROC Curve (seen attacks) |
| `val_f1` / `test_f1` | F1 score at 0.5 threshold (seen attacks) |
| `zd_auroc` | AUROC on mixed zero-day evaluation set |
| `zd_f1@0.5` | F1 at fixed τ=0.5 (zero-day) |
| `zd_f1_best` | F1 at optimally tuned τ* (zero-day) |
| `fusion_f1` | F1 using fusion score (clf + recon MSE) |

### Output Plots Generated

| Plot | Description |
|---|---|
| `metrics_curves.png` | AUROC & F1 trajectories over FL rounds |
| `trust_scores_by_round.png` | Per-client trust score T across rounds |
| `accepted_clients_by_round.png` | Scatter of which clients were accepted each round |
| `trust_components_stacked.png` | Stacked bar of A/R/C contributions per client |
| `accepted_clients_heatmap.png` | Round × Client acceptance heatmap |
| `zero_day_pr_curve.png` | Precision-Recall curve on zero-day set |
| `zero_day_roc_curve.png` | ROC curve on zero-day set |
| `zero_day_threshold_sweep.png` | Precision / Recall / F1 vs τ sweep |
| `score_distributions.png` | Benign vs zero-day classifier score histograms |
| `recon_mse_distributions.png` | Benign vs zero-day reconstruction MSE histograms |
| `fusion_vs_lambda.png` | Best zero-day F1 as a function of λ |
| `tsne_test.png` | t-SNE of bottleneck embeddings (test set) |
| `tsne_zd_mix.png` | t-SNE of bottleneck embeddings (zero-day) |
| `cm_zero_day_cls_*.png` | Classifier-only confusion matrices (counts + normalised) |
| `cm_zero_day_fuse_*.png` | Fusion confusion matrices (counts + normalised) |

### Poisoning Experiment Summary

| Experiment | Test AUROC | Test F1 | Zero-Day AUROC | Zero-Day F1 |
|---|---|---|---|---|
| ✅ Clean + Trust ON | *baseline* | *baseline* | *baseline* | *baseline* |
| ☠️ Poisoned + Trust OFF | ↓ degraded | ↓ degraded | ↓ degraded | ↓ degraded |
| 🛡️ Poisoned + Trust ON | ≈ baseline | ≈ baseline | ≈ baseline | ≈ baseline |

> *Exact numbers will vary per run. Trust ON consistently recovers performance lost under poisoning.*

---

## 🚀 Getting Started

### Prerequisites

| Library | Version |
|---|---|
| Python | 3.11 |
| TensorFlow | 2.15.0 |
| Keras | (bundled with TF 2.15) |
| scikit-learn | 1.3.2 |
| imbalanced-learn | 0.11.0 |
| pandas | ≥ 1.5 |
| numpy | < 2.0 |
| matplotlib | any |
| seaborn | any |
| pyarrow | any (for Parquet I/O) |

### Running on Kaggle (Recommended)

1. **Create a new Kaggle Notebook** and attach the [Network Intrusion Dataset](https://www.kaggle.com/datasets/chethuhn/network-intrusion-dataset)
2. Set the accelerator to **GPU** (required for TF training)
3. Enable **Internet** (required to install pinned package versions)
4. Upload `federated-learning-for-network-intrusion-detection.ipynb` and open it
5. Run **All Cells** — the notebook handles all package installation automatically

### Running Locally

```bash
# Clone the repository
git clone https://github.com/<your-username>/<your-repo>.git
cd <your-repo>

# Create and activate a virtual environment
python3 -m venv venv
source venv/bin/activate        # Windows: venv\Scripts\activate

# Install pinned dependencies
pip install scikit-learn==1.3.2 imbalanced-learn==0.11.0
pip install tensorflow==2.15.0 tensorflow-io==0.34.0
pip install pandas numpy matplotlib seaborn pyarrow jupyter

# Launch the notebook
jupyter notebook federated-learning-for-network-intrusion-detection.ipynb
```

> ⚠️ **Dataset path:** Update `extract_dir` in the data loading cells from `/kaggle/input/network-intrusion-dataset` to your local path containing the CICIDS-2017 CSV files.

---

## 📁 File Structure

```
📦 repo root
├── 📓 federated-learning-for-network-intrusion-detection.ipynb  ← main notebook
├── 📄 README.md                                                  ← this file
│
└── 📂 /kaggle/working/  (generated outputs)
    ├── 📂 EXP_CLEAN_TRUST_ON/
    │   ├── global_metrics.csv
    │   ├── trust_log.csv
    │   ├── operating_points.json
    │   └── *.png  (all plots)
    ├── 📂 EXP_POISON_BACKDOOR_TRUST_OFF/
    │   └── ...
    ├── 📂 EXP_POISON_BACKDOOR_TRUST_ON/
    │   └── ...
    ├── bin_train.parquet
    ├── bin_val.parquet
    ├── bin_test_seen_only.parquet
    ├── bin_zero_day_only.parquet
    ├── multi_train_seen_only.parquet
    ├── multi_val_seen_only.parquet
    ├── multi_test_seen_only.parquet
    ├── multiclass_index_to_label.json
    ├── features.json
    ├── bin_scaler_mean.npy  /  bin_scaler_var.npy
    └── multi_scaler_mean.npy  /  multi_scaler_var.npy
```

---

## 🔬 Research Context

This notebook accompanies a thesis on **privacy-preserving machine learning for cybersecurity**. The key research questions addressed are:

1. Can a **federated** IDS match the detection performance of a centralised IDS on seen attack types?
2. Can the **reconstruction head** of a dual autoencoder provide a reliable anomaly signal for **zero-day** attacks never seen during training?
3. Does the **A/R/C trust mechanism** meaningfully mitigate the impact of **label flip, feature noise, and backdoor poisoning** without requiring knowledge of which clients are malicious?

---

## 📖 Citation

### References

- Sharafaldin, I., Lashkari, A. H., & Ghorbani, A. A. (2018). *Toward Generating a New Intrusion Detection Dataset and Intrusion Traffic Characterization.* ICISSP.
- McMahan, H. B., et al. (2017). *Communication-Efficient Learning of Deep Networks from Decentralized Data.* AISTATS.
- Chawla, N. V., et al. (2002). *SMOTE: Synthetic Minority Over-sampling Technique.* JAIR.
- Blanchard, P., et al. (2017). *Machine Learning with Adversaries: Byzantine Tolerant Gradient Descent.* NeurIPS.

---

## 📜 License

This project is licensed under the **MIT License** — see the [LICENSE](LICENSE) file for details.

---

**⭐ If you found this project useful, please consider giving it a star!**

*Made with 🛡️ for safer networks*

</div>

Trust-Aware-Federated-Learning-for-Network-Intrusion-Detection

Trust-Aware-Federated-Learning-for-Network-Intrusion-Detection 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Trust-Aware-Federated-Learning-for-Network-Intrusion-Detection

Trust-Aware-Federated-Learning-for-Network-Intrusion-Detection 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README