Run all `num_rounds` FL rounds. Parameters ---------- callback : optional function called after each round

w_global = (1/N) Σ w_i (Eq. 7) If client_sizes provided, uses weighted average (proportional to local dataset siz

Stack all parameter tensors into a single 1-D numpy array.

Evaluate global model accuracy on (X, y). If adversarial=True, first perturb with PGD.

Returns list of client IDs whose reputation ≥ τ. Only these clients' updates are aggregated.

Approximate per-node features by repeating the batch mean. In production, each node would have its own traffic summary.

Generate realistic synthetic history for demo mode.

Return local model weights. If malicious: inject poisoned updates instead.

Verify chain integrity by recomputing all hashes.

Load global model weights into the local model.

Apply Eq. 9: R_i ← λ·R_i + (1-λ)·S_i Record on ledger.

Robustness = Acc(adversarial) / Acc(clean) (Eq. 12) Uses val set with PGD perturbation.

Compute mean weights over currently trusted clients.

S_i = weighted combination of: • accuracy – how well the client's update improved validation acc • consistency – cosin

Returns indices of clients that pass the cosine filter. If no global model yet → accept all.

Full anomaly-aware aggregation pipeline. Returns ------- aggregated global weights

Injects a fixed-pattern trigger into the last `trigger_features` dimensions of every sample. In a backdoor attack the adversary trains w

Builds a random Erdős–Rényi edge index for the IoT device graph G = (V, E) as described in Section III-A. Returns ------- edge_i

Aggregate summary metrics from the full training history. Returns ------- dict with final accuracy, robustness, malicious detection

Measures how similar a client's update is to the benign cluster mean using normalised cosine similarity. High similarity → trustworthy u

Fast Gradient Sign Method (Eq. 5): δ = ε · sign( ∇_x J(θ, x, y) ) x_adv = x + δ Parameters ---------- model : Th

Wrapper that generates adversarial samples for adversarial training (Section III-B). Randomly mixes clean and adversarial samples based

Creates a labelled synthetic traffic dataset. Each class has its own mean vector so that the five traffic categories are distinguishable

Byzantine-resilient Krum aggregation (Eq. 8). Algorithm: 1. Flatten each client's weights → vectors v_1 … v_N 2. For each v_i co

Load pre-computed results from results/metrics.json or generate synthetic demonstration data.

Run `local_epochs` of training on the local partition. For benign clients → adversarial training (FGSM/PGD) For malicious c

Multi-Krum: selects the top-m clients by Krum score and averages their updates. More robust than single-Krum for larger federations.

Non-IID partition via Dirichlet distribution (Dir(α)). Lower α → more heterogeneous label distributions. Returns ------- List of

Projected Gradient Descent (Eq. 6): x_t+1 = Proj_ε( x_t + α · sign( ∇_x J(θ, x_t, y) ) ) Stronger iterative version of FGSM.

Simulates a Byzantine client that submits deliberately corrupted weight updates. Strategy: scale weights by a large random factor + Gaus

End-to-end data preparation: 1. Generate (or load) raw data 2. Standardise features 3. Train / val / test split 4. Partit

Pretty-print the final metrics summary.

Execute one complete federated learning round.

Coordinate-wise trimmed mean. Removes the top and bottom `trim_ratio` fraction of values at each coordinate before averaging.

Baseline numbers from Table II and Table III of the paper. Used for the comparison chart.

Eq. 10: Accuracy = (TP + TN) / (TP + TN + FP + FN)

Eq. 11: FPR = FP / (FP + TN)

Eq. 12: Robustness = Accuracy(adversarial) / Accuracy(clean)

Evaluate local model on validation / test data. Returns accuracy (float in [0, 1]).

h : (num_nodes, in_dim) edge_index : (2, num_edges) — [source_nodes, target_nodes]

x : (batch, seq_len, input_dim) Returns H : (batch, d_model) — Eq. 2

x_seq : (batch, seq_len, input_dim) — sequential traffic node_feats : (num_nodes, input_dim) — per-device features

Return model parameters as a flat list for FL aggregation.

IID partition: each client receives an equal, random slice. Returns ------- List of (X_i, y_i) tuples, one per client.

Static chart replicating Table IV.

Restore a client to initial reputation (manual override).

Load aggregated global weights back into the model.

Dict snapshot for logging / dashboard.

Reconstruct the weight list from a flat numpy array.