OSCR

Byzantine robust federated learning for heterogeneous brain MRI using multisignal gradient fingerprinting and adaptive trust aggregation.

Code ↔ Paper

32 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 32 matches
  1. [1] § Results › Multi-seed validation, failure-mode analysis, and overhead comparison ↔ run_r3_experiments.py, lines 1–60 · score 0.92 · headline accuracy, failure modes, adaptive attacker, attack budgets, SignGuard, R3 experiments
  2. [2] § Results › Multi-seed validation, failure-mode analysis, and overhead comparison › Summary of R3 additional analyses ↔ run_r3_experiments.py, lines 1–60 · score 0.81 · adaptive attacker, R3 experiments, attack budgets, FLTrust, multi seed, FedAvg
  3. [3] § Results › Optimizer comparison ↔ run_r2_experiments.py, lines 1000–1010 · score 0.80 · FedDWA, FedNova, FedADMM, FedProx, FedBN, FedAvg
  4. [4] § Results › Component ablation analysis ↔ run_r2_experiments.py, lines 620–747 · score 0.80 · Acc r13, Acc r25, dynamic attack schedule, 13–25, phase transition, 1–12
  5. [5] § Results › Multi-seed validation, failure-mode analysis, and overhead comparison › Multi-seed statistical validation with paired tests (R3-C) ↔ run_all_experiments.py, lines 1–49 · score 0.78 · Wilcoxon signed rank, confidence interval, FLTrust, FedBN, FedAvg, Cohen
  6. [6] § Results › Robustness under dynamic attack schedule ↔ run_r2_experiments.py, lines 620–747 · score 0.76 · Malicious clients behave, phase transition, attack schedules, 1–12, switch, dynamic
  7. [7] § Results › Multi-seed validation, failure-mode analysis, and overhead comparison › Additional Byzantine-robust baselines (R3-F) ↔ federated_learning/training/server.py, lines 1049–1115 · score 0.76 · SignGuard, robust aggregators, FLTrust, FedBN, FedAvg, trust scoring
  8. [8] § Results › Multi-seed validation, failure-mode analysis, and overhead comparison › Computational and communication overhead (R3-B) ↔ federated_learning/config/config.py, lines 233–236 · score 0.72 · peak GPU memory, wall clock, Communication volume, MB, overhead, R3
  9. [9] § Methods › Six-dimensional gradient fingerprinting ↔ federated_learning/utils/shapley_utils.py, lines 300–368 · score 0.72 · Monte Carlo Shapley, marginal contribution, random permutations, clients, gradient
  10. [10] § Results › Multi-seed validation, failure-mode analysis, and overhead comparison › Adaptive attacker evaluation (R3-D) ↔ federated_learning/training/client.py, lines 103–160 · score 0.72 · inner loop, malicious direction, VAE aware, radius, snapshot, PGD
  11. [11] § Results › Robustness under dynamic attack schedule ↔ federated_learning/training/server.py, lines 824–874 · score 0.70 · linear combination, fixed threshold, equal weight, fingerprint features, dual attention, R3
  12. [12] § Results › Component ablation analysis ↔ run_all_experiments.py, lines 1246–1330 · score 0.70 · Removing RL adaptation, Removing VAE fingerprinting, removing Shapley, computation, component, ablation
  13. [13] § Results ↔ run_all_experiments.py, lines 1–49 · score 0.69 · confidence intervals, OASIS clinical, Scalability evaluation, baseline comparison, adversarial, std
  14. [14] § Results › Multi-seed validation, failure-mode analysis, and overhead comparison › Summary of R3 additional analyses ↔ federated_learning/config/config.py, lines 233–236 · score 0.69 · peak GPU memory, wall clock, communication volume, overhead, R3, aggregator
  15. [15] § Methods › FedBN-P optimizer: masked proximal hybrid ↔ federated_learning/utils/model_utils.py, lines 14–128 · score 0.66 · BatchNorm, proximal term, BN parameters, FedBN, optimizers
  16. [16] § Results › Component ablation analysis ↔ main.py, lines 510–566 · score 0.65 · detection accuracy, detection recall, detection metrics, Detection precision, noise, scoring
  17. [17] § Results › Multi-seed validation, failure-mode analysis, and overhead comparison › Additional Byzantine-robust baselines (R3-F) ↔ federated_learning/aggregators/byzantine_baselines.py, lines 184–269 · score 0.65 · norm filter, sign cluster, SignGuard, median, baseline, Byzantine
  18. [18] § Results › Experimental configuration ↔ run_optimized_experiments.py, lines 1–53 · score 0.65 · minority class, Class imbalance, real clinical, severity, OASIS, training
  19. [19] § Results › Component ablation analysis ↔ run_all_experiments.py, lines 1246–1330 · score 0.64 · Removing VAE, Removing RL, component ablation, real clinical, fingerprint, metrics
  20. [20] § Results › Optimizer comparison ↔ run_r2_experiments.py, lines 1000–1010 · score 0.63 · FedNova, FedProx, FedBN, FedAvg, SCAFFOLD, Optimizer
  21. [21] § Methods › FedBN-P optimizer: masked proximal hybrid ↔ federated_learning/training/server.py, lines 1049–1115 · score 0.61 · BatchNorm, proximal term, FedBN, hybrid, Byzantine, RL
  22. [22] § Results › Experimental configuration ↔ federated_learning/data/cifar_dataset.py, lines 9–64 · score 0.60 · random horizontal flips, random crops, augmented, CIFAR, training
  23. [23] § Methods › Implementation details ↔ federated_learning/models/resnet.py, lines 7–56 · score 0.60 · fully connected, ReLU, ResNet, dropout, layer, class
  24. [24] § Results › Multi-seed validation, failure-mode analysis, and overhead comparison › Additional Byzantine-robust baselines (R3-F) ↔ federated_learning/aggregators/byzantine_baselines.py, lines 184–269 · score 0.60 · sign clustering filtering, SignGuard, distance, median, baseline, Byzantine
  25. [25] § Results › Robustness under dynamic attack schedule ↔ federated_learning/config/config.py, lines 228–231 · score 0.60 · linear combination, equal weight, fingerprint features, dual attention, R3, ablation
  26. [26] § Methods › FedBN-P optimizer: masked proximal hybrid ↔ federated_learning/utils/model_utils.py, lines 14–128 · score 0.59 · BatchNorm, BN parameters, model parameters, proximal, optimizer
  27. [27] § Results › Experimental configuration ↔ federated_learning/utils/data_utils.py, lines 15–106 · score 0.57 · random horizontal flips, random crops, CIFAR, MNIST, training
  28. [28] § Results › Multi-seed validation, failure-mode analysis, and overhead comparison › Failure-mode characterization under varying attack intensity (R3-A) ↔ run_r3_experiments.py, lines 388–446 · score 0.56 · attack budgets, malicious fraction, sign flip, sweeps, intensity, failure
  29. [29] § Methods › FedBN-P optimizer: masked proximal hybrid ↔ federated_learning/training/aggregation.py, lines 209–254 · score 0.56 · proximal term, BN parameters, FedBN, masked, client
  30. [30] § Results › Component ablation analysis ↔ run_r2_experiments.py, lines 349–392 · score 0.55 · VAE fingerprinting component, Gaussian noise injection, ablation, validate, seed, rounds
  31. [31] § Results › Component ablation analysis ↔ run_revision_experiments.py, lines 164–212 · score 0.53 · Peer consensus, L2 norm, dual attention, ratio, cosine, fingerprint
  32. [32] § Results › Multi-seed validation, failure-mode analysis, and overhead comparison › Computational and communication overhead (R3-B) ↔ federated_learning/training/server.py, lines 1157–1239 · score 0.51 · wall clock, MB, cache, volume, peak, overhead

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 1,331 lines · 54 KB · MIT · 5 matches

  1. #!/usr/bin/env python3
  2. """
  3. =============================================================================
  4. OptiGradTrust -- Second Revision (R2) Experiment Runner
  5. =============================================================================
  7. Implements ALL experiments required by Reviewer 1 in the second revision:
  9. Experiment 1A: Multi-attack ablation under GAUSSIAN NOISE INJECTION
  10. (validates VAE component)
  11. Experiment 1B: Multi-attack ablation under SIGN-FLIPPING
  12. (validates cosine-similarity / sign-consistency)
  13. Experiment 2: Dynamic attack schedule (RL justification) -- CRITICAL
  14. Phase transition: rounds 1-12 benign, 13-25 scaling x20
  15. Experiment 3: Trust score / Shapley visualization (qualitative figure)
  16. Experiment 4: Optimizer comparison under adversarial conditions
  18. USAGE:
  19. python run_r2_experiments.py --experiment exp1a # Noise ablation
  20. python run_r2_experiments.py --experiment exp1b # Sign-flip ablation
  21. python run_r2_experiments.py --experiment exp2 # Dynamic attack (CRITICAL)
  22. python run_r2_experiments.py --experiment exp3 # Trust visualization
  23. python run_r2_experiments.py --experiment exp4 # Optimizer adversarial
  24. python run_r2_experiments.py --experiment all # Run all
  25. python run_r2_experiments.py --experiment exp2 --dry-run # Sanity check
  27. # Multi-seed options (use for critical experiments):
  28. python run_r2_experiments.py --experiment exp2 --seeds 42 123 456
  29. python run_r2_experiments.py --experiment exp1a --seeds 42 123 456 789 1024
  31. Author: OptiGradTrust Team
  32. =============================================================================
  33. """
  35. import matplotlib
  36. matplotlib.use('Agg')
  38. import os
  39. import sys
  40. import json
  41. import time
  42. import copy
  43. import csv
  44. import argparse
  45. import traceback
  46. import warnings
  47. import numpy as np
  48. import torch
  49. import torch.nn.functional as F
  50. import matplotlib.pyplot as plt
  51. import matplotlib.patches as mpatches
  52. from contextlib import contextmanager
  53. from datetime import datetime
  54. from typing import Dict, List, Optional, Tuple
  56. warnings.filterwarnings('ignore')
  58. PROJECT_ROOT = os.path.dirname(os.path.abspath(__file__))
  59. sys.path.insert(0, PROJECT_ROOT)
  61. from run_all_experiments import (
  62. set_all_seeds, configure_for_dataset,
  63. compute_statistics, Logger, _sync_config_to_modules
  64. )
  66. # ---------------------------------------------------------------------------
  67. # Output directory & logger
  68. # ---------------------------------------------------------------------------
  69. RESULTS_DIR = os.path.join(PROJECT_ROOT, 'results', 'r2_revision')
  70. os.makedirs(RESULTS_DIR, exist_ok=True)
  72. LOG_FILE = os.path.join(
  73. RESULTS_DIR,
  74. f'r2_log_{datetime.now().strftime("%Y%m%d_%H%M%S")}.txt'
  75. )
  76. logger = Logger(LOG_FILE)
  79. # ===========================================================================
  80. # SHARED ABLATION CONFIGURATIONS
  81. # ===========================================================================
  83. # The five standard ablation configurations (same structure as Table 9)
  84. ABLATION_CONFIGS = [
  85. {'name': 'full', 'vae': True, 'shapley': True, 'dual_attention': True, 'rl': True},
  86. {'name': 'no_vae', 'vae': False, 'shapley': True, 'dual_attention': True, 'rl': True},
  87. {'name': 'no_shapley', 'vae': True, 'shapley': False, 'dual_attention': True, 'rl': True},
  88. {'name': 'no_rl', 'vae': True, 'shapley': True, 'dual_attention': True, 'rl': False},
  89. {'name': 'fedavg_no_def', 'vae': False, 'shapley': False, 'dual_attention': False, 'rl': False,
  90. '_fedavg': True},
  91. ]
  93. # Extra sign-flipping specific configs (optional if time allows)
  94. SIGNFLIP_EXTRA_CONFIGS = [
  95. {'name': 'no_cosine_sim', 'vae': True, 'shapley': True, 'dual_attention': True, 'rl': True,
  96. '_zero_features': [1, 2]}, # zero root-cosine (1) and peer-consensus (2)
  97. {'name': 'no_sign_consist', 'vae': True, 'shapley': True, 'dual_attention': True, 'rl': True,
  98. '_zero_features': [4]}, # zero sign-consistency (4)
  99. ]
  102. # ===========================================================================
  103. # FEATURE-ZEROING PATCH (same technique as run_revision_experiments.py)
  104. # ===========================================================================
  106. @contextmanager
  107. def _patch_feature_zeroing(zero_indices):
  108. """Monkey-patch Server._compute_all_gradient_features to zero specific feature columns."""
  109. from federated_learning.training.server import Server
  110. original_fn = Server._compute_all_gradient_features
  112. def _patched(self, client_gradients):
  113. features = original_fn(self, client_gradients)
  114. if isinstance(features, torch.Tensor):
  115. for idx in zero_indices:
  116. if idx < features.size(1):
  117. features[:, idx] = 0.5 # neutral / uninformative
  118. return features
  120. Server._compute_all_gradient_features = _patched
  121. try:
  122. yield
  123. finally:
  124. Server._compute_all_gradient_features = original_fn
  127. # ===========================================================================
  128. # LOW-LEVEL EXPERIMENT RUNNER (shared by Exp 1A, 1B)
  129. # ===========================================================================
  131. def _apply_alzheimer_ablation_config(cfg_mod, ablation_cfg, num_rounds):
  132. """
  133. Set Alzheimer ablation config parameters exactly as described in the R2 report:
  134. - 10 clients, 40% malicious, Dirichlet alpha=0.1, 25 rounds
  135. - Batch=16, LR=1e-4, weight_decay=5e-5, FedBN-P (mu=0.01)
  136. """
  137. cfg_mod.GLOBAL_EPOCHS = num_rounds
  138. cfg_mod.FRACTION_MALICIOUS = 0.4
  139. cfg_mod.NUM_MALICIOUS = 4
  140. cfg_mod.BATCH_SIZE = 16
  141. cfg_mod.LR = 1e-4
  142. cfg_mod.LEARNING_RATE = 1e-4
  143. cfg_mod.WEIGHT_DECAY = 5e-5
  144. cfg_mod.FEDPROX_MU = 0.01
  146. is_fedavg_no_def = ablation_cfg.get('_fedavg', False)
  148. if is_fedavg_no_def:
  149. cfg_mod.ENABLE_VAE = False
  150. cfg_mod.ENABLE_SHAPLEY = False
  151. cfg_mod.ENABLE_DUAL_ATTENTION = False
  152. cfg_mod.RL_AGGREGATION_METHOD = 'dual_attention'
  153. cfg_mod.RL_WARMUP_ROUNDS = 9999
  154. cfg_mod.AGGREGATION_METHOD = 'fedavg'
  155. cfg_mod.GRADIENT_COMBINATION_METHOD = 'fedavg'
  156. else:
  157. cfg_mod.ENABLE_VAE = ablation_cfg.get('vae', True)
  158. cfg_mod.ENABLE_SHAPLEY = ablation_cfg.get('shapley', True)
  159. cfg_mod.ENABLE_DUAL_ATTENTION = ablation_cfg.get('dual_attention', True)
  160. if not ablation_cfg.get('rl', True):
  161. cfg_mod.RL_AGGREGATION_METHOD = 'dual_attention'
  162. cfg_mod.RL_WARMUP_ROUNDS = 9999
  163. else:
  164. cfg_mod.RL_AGGREGATION_METHOD = 'hybrid'
  165. cfg_mod.RL_WARMUP_ROUNDS = 5
  166. cfg_mod.RL_RAMP_UP_ROUNDS = 10
  167. cfg_mod.AGGREGATION_METHOD = 'fedbn_fedprox'
  168. cfg_mod.GRADIENT_COMBINATION_METHOD = 'fedbn_fedprox'
  171. def _run_ablation_single(attack_type, ablation_cfg, seed, num_rounds, sigma=15.0):
  172. """
  173. Run one ablation configuration for a given attack type and seed.
  174. Returns a result dict.
  175. """
  176. import federated_learning.config.config as cfg_mod
  177. from federated_learning.training.server import Server
  178. from federated_learning.training.client import Client
  179. from federated_learning.data.dataset_utils import load_dataset, create_client_datasets
  180. from federated_learning.utils.model_utils import set_random_seeds
  182. cfg_name = ablation_cfg.get('name', 'unknown')
  183. logger.info(f" [{cfg_name}] seed={seed} attack={attack_type}")
  185. set_all_seeds(seed)
  187. configure_for_dataset(
  188. 'ALZHEIMER', num_clients=10,
  189. non_iid_config={'enable': True, 'type': 'dirichlet', 'alpha': 0.1},
  190. aggregation_method='fedbn_fedprox'
  191. )
  192. cfg_mod.RANDOM_SEED = seed
  193. _apply_alzheimer_ablation_config(cfg_mod, ablation_cfg, num_rounds)
  194. _sync_config_to_modules()
  196. set_random_seeds(seed)
  197. start_t = time.time()
  199. try:
  200. train_dataset, test_dataset = load_dataset()
  201. root_loader = torch.utils.data.DataLoader(
  202. train_dataset, batch_size=cfg_mod.BATCH_SIZE, shuffle=True, num_workers=0)
  204. server = Server()
  205. server.set_datasets(root_loader, test_dataset)
  206. server._pretrain_global_model()
  208. _, client_datasets = create_client_datasets(
  209. train_dataset=train_dataset, num_clients=10, iid=False, alpha=0.1)
  211. malicious_indices = np.random.choice(10, 4, replace=False)
  212. clients = []
  213. for i in range(10):
  214. is_mal = int(i) in malicious_indices.tolist()
  215. c = Client(client_id=i, dataset=client_datasets[i], is_malicious=is_mal)
  216. if is_mal:
  217. c.set_attack_parameters(
  218. attack_type=attack_type,
  219. scaling_factor=20.0,
  220. sigma=sigma,
  221. partial_percent=cfg_mod.PARTIAL_SCALING_PERCENT,
  222. noise_factor=cfg_mod.NOISE_FACTOR,
  223. flip_probability=cfg_mod.FLIP_PROBABILITY,
  224. )
  225. clients.append(c)
  226. server.add_clients(clients)
  228. root_gradients = server._collect_root_gradients()
  229. server.root_gradients = root_gradients # enables root-cosine & sign-consistency features
  230. if getattr(cfg_mod, 'ENABLE_VAE', True):
  231. server.vae = server.train_vae(root_gradients, vae_epochs=cfg_mod.VAE_EPOCHS)
  232. else:
  233. server.vae = None
  235. test_loader = torch.utils.data.DataLoader(
  236. test_dataset, batch_size=cfg_mod.BATCH_SIZE, shuffle=False, num_workers=0)
  237. server.test_loader = test_loader
  239. # Run training, applying optional feature-zeroing patch
  240. zero_feats = ablation_cfg.get('_zero_features')
  241. if zero_feats:
  242. with _patch_feature_zeroing(zero_feats):
  243. _, round_metrics = server.train(num_rounds=cfg_mod.GLOBAL_EPOCHS)
  244. else:
  245. _, round_metrics = server.train(num_rounds=cfg_mod.GLOBAL_EPOCHS)
  247. final_acc = server.evaluate_model()
  249. # Aggregate detection metrics over all rounds
  250. total_tp = total_fp = total_fn = total_tn = 0
  251. for rd in round_metrics.values():
  252. det = rd.get('detection_results', {})
  253. total_tp += det.get('true_positives', 0)
  254. total_fp += det.get('false_positives', 0)
  255. total_fn += det.get('false_negatives', 0)
  256. total_tn += det.get('true_negatives', 0)
  258. precision = total_tp / (total_tp + total_fp) if (total_tp + total_fp) > 0 else 0.0
  259. recall = total_tp / (total_tp + total_fn) if (total_tp + total_fn) > 0 else 0.0
  260. f1 = (2 * precision * recall / (precision + recall)
  261. if (precision + recall) > 0 else 0.0)
  263. result = {
  264. 'config_name': cfg_name,
  265. 'seed': seed,
  266. 'attack_type': attack_type,
  267. 'final_accuracy': float(final_acc),
  268. 'precision': float(precision),
  269. 'recall': float(recall),
  270. 'f1': float(f1),
  271. 'total_time': time.time() - start_t,
  272. 'status': 'completed',
  273. }
  274. logger.success(
  275. f" → Acc={final_acc*100:.2f}% "
  276. f"Prec={precision*100:.2f} Rec={recall*100:.2f} F1={f1*100:.2f}"
  277. )
  278. return result
  280. except Exception as exc:
  281. logger.error(f" → FAILED: {str(exc)[:120]}")
  282. traceback.print_exc()
  283. return {
  284. 'config_name': cfg_name,
  285. 'seed': seed,
  286. 'attack_type': attack_type,
  287. 'status': 'failed',
  288. 'error': str(exc),
  289. 'total_time': time.time() - start_t,
  290. }
  293. def _save_ablation_table(results, filename_base, attack_label):
  294. """Save CSV + print a formatted text table for ablation results."""
  295. completed = [r for r in results if r.get('status') == 'completed']
  297. # CSV
  298. csv_path = os.path.join(RESULTS_DIR, f'{filename_base}.csv')
  299. fields = ['config_name', 'seed', 'attack_type',
  300. 'final_accuracy', 'precision', 'recall', 'f1', 'total_time', 'status']
  301. with open(csv_path, 'w', newline='') as f:
  302. w = csv.DictWriter(f, fieldnames=fields, extrasaction='ignore')
  303. w.writeheader()
  304. w.writerows(results)
  305. logger.info(f" Saved CSV → {csv_path}")
  307. # JSON
  308. json_path = os.path.join(RESULTS_DIR, f'{filename_base}.json')
  309. with open(json_path, 'w') as f:
  310. json.dump(results, f, indent=2, default=str)
  311. logger.info(f" Saved JSON → {json_path}")
  313. # Pretty table
  314. header = (f"\n{'='*80}\n"
  315. f"ABLATION TABLE — {attack_label}\n"
  316. f"{'Configuration':<26} {'Acc (%)':>9} {'ΔAcc':>7} "
  317. f"{'Recall (%)':>11} {'F1 (%)':>8}\n"
  318. f"{'-'*80}")
  319. logger.info(header)
  321. # Compute full-system accuracy as baseline for delta
  322. full_acc = None
  323. for r in completed:
  324. if r['config_name'] == 'full':
  325. full_acc = r['final_accuracy']
  326. break
  328. for r in completed:
  329. acc = r['final_accuracy'] * 100
  330. delta = ((r['final_accuracy'] - full_acc) * 100
  331. if full_acc is not None and r['config_name'] != 'full' else 0.0)
  332. delta_str = f"{delta:+.2f}" if r['config_name'] != 'full' else " --"
  333. is_fedavg = 'fedavg' in r['config_name']
  334. recall_str = f"{r['recall']*100:.2f}" if not is_fedavg else " --"
  335. f1_str = f"{r['f1']*100:.2f}" if not is_fedavg else " --"
  336. logger.info(
  337. f" {r['config_name']:<24} {acc:>9.2f} {delta_str:>7} "
  338. f"{recall_str:>11} {f1_str:>8}"
  339. )
  341. logger.info('=' * 80)
  342. return csv_path, json_path
  345. # ===========================================================================
  346. # EXPERIMENT 1A — GAUSSIAN NOISE INJECTION ABLATION
  347. # ===========================================================================
  349. def run_exp1a_noise_ablation(seeds=None, dry_run=False):
  350. """
  351. Experiment 1A: Ablation under Gaussian Noise Injection (sigma=15.0).
  352. Validates the VAE fingerprinting component.
  353. """
  354. logger.info('=' * 70)
  355. logger.info('EXPERIMENT 1A: ABLATION UNDER GAUSSIAN NOISE INJECTION')
  356. logger.info(' Dataset: Alzheimer MRI | Clients: 10 | Malicious: 40%')
  357. logger.info(' Attack: gaussian_noise_injection sigma=15.0 | alpha=0.1 | 25 rounds')
  358. logger.info('=' * 70)
  360. if seeds is None:
  361. seeds = [42]
  362. if dry_run:
  363. seeds = [42]
  364. num_rounds = 2 if dry_run else 25
  366. all_results = []
  368. configs_to_run = ABLATION_CONFIGS.copy()
  370. for cfg in configs_to_run:
  371. logger.info(f"\n Config: {cfg['name']}")
  372. seed_results = []
  373. for seed in seeds:
  374. r = _run_ablation_single(
  375. attack_type='gaussian_noise_injection',
  376. ablation_cfg=cfg,
  377. seed=seed,
  378. num_rounds=num_rounds,
  379. sigma=15.0,
  380. )
  381. all_results.append(r)
  382. if r['status'] == 'completed':
  383. seed_results.append(r)
  385. if len(seed_results) > 1:
  386. accs = [r['final_accuracy'] for r in seed_results]
  387. logger.info(f" Mean Acc: {np.mean(accs)*100:.2f}% ± {np.std(accs)*100:.2f}%")
  389. _save_ablation_table(all_results, 'exp1a_noise_ablation',
  390. 'Gaussian Noise Injection (sigma=15.0) | Alzheimer MRI')
  391. logger.info('\nExperiment 1A complete.')
  392. return all_results
  395. # ===========================================================================
  396. # EXPERIMENT 1B — SIGN-FLIPPING ABLATION
  397. # ===========================================================================
  399. def run_exp1b_signflip_ablation(seeds=None, dry_run=False, include_optional=True):
  400. """
  401. Experiment 1B: Ablation under Sign-Flipping (lambda=-1).
  402. Validates cosine-similarity and sign-consistency components.
  403. """
  404. logger.info('=' * 70)
  405. logger.info('EXPERIMENT 1B: ABLATION UNDER SIGN-FLIPPING (lambda=-1)')
  406. logger.info(' Dataset: Alzheimer MRI | Clients: 10 | Malicious: 40%')
  407. logger.info(' Attack: sign_flipping_attack | alpha=0.1 | 25 rounds')
  408. logger.info('=' * 70)
  410. if seeds is None:
  411. seeds = [42]
  412. if dry_run:
  413. seeds = [42]
  414. num_rounds = 2 if dry_run else 25
  416. all_results = []
  417. configs_to_run = ABLATION_CONFIGS.copy()
  418. if include_optional and not dry_run:
  419. configs_to_run += SIGNFLIP_EXTRA_CONFIGS
  421. for cfg in configs_to_run:
  422. logger.info(f"\n Config: {cfg['name']}")
  423. seed_results = []
  424. for seed in seeds:
  425. r = _run_ablation_single(
  426. attack_type='sign_flipping_attack',
  427. ablation_cfg=cfg,
  428. seed=seed,
  429. num_rounds=num_rounds,
  430. )
  431. all_results.append(r)
  432. if r['status'] == 'completed':
  433. seed_results.append(r)
  435. if len(seed_results) > 1:
  436. accs = [r['final_accuracy'] for r in seed_results]
  437. logger.info(f" Mean Acc: {np.mean(accs)*100:.2f}% ± {np.std(accs)*100:.2f}%")
  439. _save_ablation_table(all_results, 'exp1b_signflip_ablation',
  440. 'Sign-Flipping (lambda=-1) | Alzheimer MRI')
  441. logger.info('\nExperiment 1B complete.')
  442. return all_results
  445. # ===========================================================================
  446. # EXPERIMENT 2 — DYNAMIC ATTACK SCHEDULE (RL JUSTIFICATION)
  447. # ===========================================================================
  449. EXP2_CONFIGS = [
  450. {'name': 'full', 'vae': True, 'shapley': True, 'dual_attention': True, 'rl': True},
  451. {'name': 'no_rl', 'vae': True, 'shapley': True, 'dual_attention': True, 'rl': False},
  452. {'name': 'fedavg_no_def', 'vae': False, 'shapley': False, 'dual_attention': False, 'rl': False,
  453. '_fedavg': True},
  454. ]
  457. def _run_exp2_single(cfg, seed, num_rounds, phase_transition_round=12):
  458. """
  459. Run one configuration of Experiment 2 (dynamic attack, phase-transition schedule).
  461. Phase transition:
  462. rounds 1–12 (round_idx 0–11): malicious clients behave BENIGNLY
  463. rounds 13–25 (round_idx 12–24): malicious clients launch scaling x20
  465. Returns dict with per-round accuracy + detection, and final summary metrics.
  466. """
  467. import federated_learning.config.config as cfg_mod
  468. from federated_learning.training.server import Server
  469. from federated_learning.training.client import Client
  470. from federated_learning.data.dataset_utils import load_dataset, create_client_datasets
  471. from federated_learning.utils.model_utils import set_random_seeds
  473. cfg_name = cfg.get('name', 'unknown')
  474. logger.info(f" [Exp2 | {cfg_name}] seed={seed}")
  476. set_all_seeds(seed)
  478. configure_for_dataset(
  479. 'ALZHEIMER', num_clients=10,
  480. non_iid_config={'enable': True, 'type': 'dirichlet', 'alpha': 0.1},
  481. aggregation_method='fedbn_fedprox'
  482. )
  483. cfg_mod.RANDOM_SEED = seed
  484. _apply_alzheimer_ablation_config(cfg_mod, cfg, num_rounds)
  485. # For Exp 2, use RL in ACTIVE training mode (not frozen)
  486. # RL must be actively training during all 25 rounds
  487. if not cfg.get('_fedavg', False) and cfg.get('rl', True):
  488. cfg_mod.RL_AGGREGATION_METHOD = 'hybrid'
  489. cfg_mod.RL_WARMUP_ROUNDS = 5
  490. cfg_mod.RL_RAMP_UP_ROUNDS = 10
  491. _sync_config_to_modules()
  493. set_random_seeds(seed)
  494. start_t = time.time()
  496. try:
  497. train_dataset, test_dataset = load_dataset()
  498. root_loader = torch.utils.data.DataLoader(
  499. train_dataset, batch_size=cfg_mod.BATCH_SIZE, shuffle=True, num_workers=0)
  501. server = Server()
  502. server.set_datasets(root_loader, test_dataset)
  503. server._pretrain_global_model()
  505. _, client_datasets = create_client_datasets(
  506. train_dataset=train_dataset, num_clients=10, iid=False, alpha=0.1)
  508. malicious_indices = np.random.choice(10, 4, replace=False)
  509. clients = []
  510. for i in range(10):
  511. is_mal = int(i) in malicious_indices.tolist()
  512. c = Client(client_id=i, dataset=client_datasets[i], is_malicious=is_mal)
  513. if is_mal:
  514. c.set_attack_parameters(
  515. attack_type='scaling_attack',
  516. scaling_factor=20.0,
  517. partial_percent=cfg_mod.PARTIAL_SCALING_PERCENT,
  518. noise_factor=cfg_mod.NOISE_FACTOR,
  519. flip_probability=cfg_mod.FLIP_PROBABILITY,
  520. )
  521. # Phase-transition schedule: benign for rounds 0..(T-1), then attack
  522. c.dynamic_attack_schedule = 'phase_transition'
  523. c.phase_transition_round = phase_transition_round # 0-indexed
  525. clients.append(c)
  526. server.add_clients(clients)
  528. root_gradients = server._collect_root_gradients()
  529. server.root_gradients = root_gradients # enables root-cosine & sign-consistency features
  530. if getattr(cfg_mod, 'ENABLE_VAE', True):
  531. server.vae = server.train_vae(root_gradients, vae_epochs=cfg_mod.VAE_EPOCHS)
  532. else:
  533. server.vae = None
  535. test_loader = torch.utils.data.DataLoader(
  536. test_dataset, batch_size=cfg_mod.BATCH_SIZE, shuffle=False, num_workers=0)
  537. server.test_loader = test_loader
  539. _, round_metrics = server.train(num_rounds=cfg_mod.GLOBAL_EPOCHS)
  540. final_acc = server.evaluate_model()
  542. # Build per-round metrics (round_metrics[r]['test_accuracy'] = accuracy
  543. # measured BEFORE the update in round r+1, i.e. after completing r rounds)
  544. per_round = {}
  545. for r_idx, rd in round_metrics.items():
  546. acc_before_update = rd.get('test_accuracy', 0.0)
  547. det = rd.get('detection_results', {})
  548. tp = det.get('true_positives', 0)
  549. fp = det.get('false_positives', 0)
  550. fn = det.get('false_negatives', 0)
  551. recall_r = tp / (tp + fn) if (tp + fn) > 0 else 0.0
  552. precision_r = tp / (tp + fp) if (tp + fp) > 0 else 0.0
  553. f1_r = (2 * precision_r * recall_r / (precision_r + recall_r)
  554. if (precision_r + recall_r) > 0 else 0.0)
  555. per_round[int(r_idx)] = {
  556. 'accuracy': float(acc_before_update),
  557. 'detection_recall': float(recall_r),
  558. 'detection_f1': float(f1_r),
  559. 'is_attack_phase': int(r_idx) >= phase_transition_round,
  560. }
  562. # Summary key rounds (1-indexed in paper):
  563. # r13 = just before attack, r18 = 5 rds after, r25 = final
  564. def _get_acc(round_1indexed):
  565. r0 = round_1indexed - 1 # convert to 0-indexed round_metrics key
  566. if r0 in per_round:
  567. return per_round[r0]['accuracy']
  568. return None
  570. def _get_det_f1_range(from_round, to_round):
  571. """Mean detection F1 over a range of rounds (1-indexed)."""
  572. vals = [per_round[r-1]['detection_f1']
  573. for r in range(from_round, to_round+1)
  574. if (r-1) in per_round]
  575. return float(np.mean(vals)) if vals else 0.0
  577. acc_r13 = _get_acc(13)
  578. acc_r18 = _get_acc(18)
  579. acc_r25 = float(final_acc) # after all 25 rounds
  581. det_f1_post_attack = _get_det_f1_range(13, 25)
  583. result = {
  584. 'config_name': cfg_name,
  585. 'seed': seed,
  586. 'per_round': per_round,
  587. 'acc_r13': acc_r13,
  588. 'acc_r18': acc_r18,
  589. 'acc_r25': acc_r25,
  590. 'det_f1_r13_to_r25': det_f1_post_attack,
  591. 'final_accuracy': float(final_acc),
  592. 'total_time': time.time() - start_t,
  593. 'status': 'completed',
  594. 'malicious_indices': malicious_indices.tolist(),
  595. }
  597. def _pct(v):
  598. return f"{v*100:.2f}%" if v is not None else "--"
  600. logger.success(
  601. f" → Acc@r13={_pct(acc_r13)} "
  602. f"Acc@r18={_pct(acc_r18)} "
  603. f"Acc@r25={_pct(acc_r25)} "
  604. f"DetF1(r13-25)={det_f1_post_attack:.3f}"
  605. )
  606. return result
  608. except Exception as exc:
  609. logger.error(f" → FAILED: {str(exc)[:120]}")
  610. traceback.print_exc()
  611. return {
  612. 'config_name': cfg_name,
  613. 'seed': seed,
  614. 'status': 'failed',
  615. 'error': str(exc),
  616. 'total_time': time.time() - start_t,
  617. }
  620. def run_exp2_dynamic_attack(seeds=None, dry_run=False):
  621. """
  622. Experiment 2 (CRITICAL / NON-NEGOTIABLE):
  623. Dynamic attack schedule — phase-transition for RL justification.
  625. Phase transition:
  626. Rounds 1–12: malicious clients behave BENIGNLY (build false trust)
  627. Rounds 13–25: malicious clients switch to SCALING x20
  629. Outputs:
  630. - Summary table (CSV + JSON): acc@r13, acc@r18, acc@r25, detection F1
  631. - Per-round CSV: for convergence figure in the paper
  632. """
  633. logger.info('=' * 70)
  634. logger.info('EXPERIMENT 2 (CRITICAL): DYNAMIC ATTACK — PHASE TRANSITION')
  635. logger.info(' Dataset: Alzheimer MRI | Clients: 10 | Malicious: 40%')
  636. logger.info(' Rounds 1-12: BENIGN → Rounds 13-25: Scaling x20')
  637. logger.info(' Validates: RL temporal adaptivity advantage')
  638. logger.info('=' * 70)
  640. if seeds is None:
  641. seeds = [42, 123, 456]
  642. if dry_run:
  643. seeds = [42]
  644. num_rounds = 3 if dry_run else 25
  645. phase_transition = 1 if dry_run else 12 # 0-indexed transition round
  647. all_results = {} # cfg_name → list of per-seed results
  648. all_per_round = [] # rows for per-round CSV
  650. for cfg in EXP2_CONFIGS:
  651. cfg_name = cfg['name']
  652. all_results[cfg_name] = []
  653. logger.info(f"\n Config: {cfg_name}")
  655. for seed in seeds:
  656. r = _run_exp2_single(cfg, seed, num_rounds, phase_transition)
  657. all_results[cfg_name].append(r)
  659. if r['status'] == 'completed':
  660. for r_idx, rd in r['per_round'].items():
  661. all_per_round.append({
  662. 'round': r_idx + 1, # 1-indexed for paper
  663. 'seed': seed,
  664. 'config': cfg_name,
  665. 'accuracy': rd['accuracy'],
  666. 'detection_recall': rd['detection_recall'],
  667. 'detection_f1': rd['detection_f1'],
  668. 'is_attack_phase': int(rd['is_attack_phase']),
  669. })
  671. # ---------- Per-round CSV ----------
  672. csv_pr_path = os.path.join(RESULTS_DIR, 'exp2_dynamic_per_round.csv')
  673. if all_per_round:
  674. fields_pr = ['round', 'seed', 'config', 'accuracy',
  675. 'detection_recall', 'detection_f1', 'is_attack_phase']
  676. with open(csv_pr_path, 'w', newline='') as f:
  677. w = csv.DictWriter(f, fieldnames=fields_pr)
  678. w.writeheader()
  679. w.writerows(all_per_round)
  680. logger.info(f"\n Saved per-round CSV → {csv_pr_path}")
  682. # ---------- Summary table ----------
  683. logger.info('\n' + '=' * 80)
  684. logger.info('EXPERIMENT 2 SUMMARY TABLE')
  685. logger.info(f"{'Configuration':<22} {'Acc@r13 (%)':>12} {'Acc@r18 (%)':>12} "
  686. f"{'Acc@r25 (%)':>12} {'DetF1 r13-25':>14}")
  687. logger.info('-' * 80)
  689. summary_rows = []
  690. for cfg in EXP2_CONFIGS:
  691. cfg_name = cfg['name']
  692. completed = [r for r in all_results[cfg_name] if r.get('status') == 'completed']
  693. if not completed:
  694. logger.warning(f" {cfg_name}: No completed runs.")
  695. continue
  697. accs13 = [r['acc_r13'] for r in completed if r.get('acc_r13') is not None]
  698. accs18 = [r['acc_r18'] for r in completed if r.get('acc_r18') is not None]
  699. accs25 = [r['acc_r25'] for r in completed]
  700. f1s = [r['det_f1_r13_to_r25'] for r in completed]
  702. def _fmt(vals):
  703. if not vals:
  704. return ' --'
  705. m = np.mean(vals) * 100
  706. s = np.std(vals) * 100
  707. return f"{m:.2f}±{s:.2f}" if len(vals) > 1 else f"{m:.2f}"
  709. is_fedavg = cfg.get('_fedavg', False)
  710. f1_str = ' --' if is_fedavg else _fmt(f1s)
  712. row_str = (f" {cfg_name:<20} {_fmt(accs13):>12} {_fmt(accs18):>12} "
  713. f"{_fmt(accs25):>12} {f1_str:>14}")
  714. logger.info(row_str)
  716. summary_rows.append({
  717. 'config_name': cfg_name,
  718. 'seeds': seeds,
  719. 'acc_r13_mean': float(np.mean(accs13)) if accs13 else None,
  720. 'acc_r13_std': float(np.std(accs13)) if accs13 else None,
  721. 'acc_r18_mean': float(np.mean(accs18)) if accs18 else None,
  722. 'acc_r18_std': float(np.std(accs18)) if accs18 else None,
  723. 'acc_r25_mean': float(np.mean(accs25)) if accs25 else None,
  724. 'acc_r25_std': float(np.std(accs25)) if accs25 else None,
  725. 'det_f1_r13_25_mean': float(np.mean(f1s)) if f1s else None,
  726. 'det_f1_r13_25_std': float(np.std(f1s)) if f1s else None,
  727. })
  729. logger.info('=' * 80)
  731. # Save summary CSV + JSON
  732. csv_sum_path = os.path.join(RESULTS_DIR, 'exp2_dynamic_summary.csv')
  733. if summary_rows:
  734. with open(csv_sum_path, 'w', newline='') as f:
  735. w = csv.DictWriter(f, fieldnames=list(summary_rows[0].keys()),
  736. extrasaction='ignore')
  737. w.writeheader()
  738. w.writerows(summary_rows)
  739. logger.info(f" Saved summary CSV → {csv_sum_path}")
  741. json_path = os.path.join(RESULTS_DIR, 'exp2_dynamic_results.json')
  742. with open(json_path, 'w') as f:
  743. json.dump(all_results, f, indent=2, default=str)
  744. logger.info(f" Saved JSON → {json_path}")
  746. logger.info('\nExperiment 2 complete.')
  747. return all_results, all_per_round
  750. # ===========================================================================
  751. # EXPERIMENT 3 — TRUST SCORE VISUALIZATION
  752. # ===========================================================================
  754. def run_exp3_trust_visualization(seed=42, dry_run=False):
  755. """
  756. Experiment 3: Qualitative trust score visualization.
  758. Runs a full OptiGradTrust experiment under scaling x20 and extracts
  759. per-client, per-round trust scores to generate:
  760. Option A: Trust Score Time Series (PREFERRED — required)
  761. Option B: Trust Score Box Plot
  762. Option C: Shapley Value Distribution (if Shapley enabled)
  764. All at ≥ 300 DPI, plus a raw-data CSV.
  765. """
  766. logger.info('=' * 70)
  767. logger.info('EXPERIMENT 3: TRUST SCORE / SHAPLEY VISUALIZATION')
  768. logger.info(' Dataset: Alzheimer MRI | Attack: Scaling x20')
  769. logger.info(' Configuration: Full OptiGradTrust | Seed=42 | 25 rounds')
  770. logger.info('=' * 70)
  772. import federated_learning.config.config as cfg_mod
  773. from federated_learning.training.server import Server
  774. from federated_learning.training.client import Client
  775. from federated_learning.data.dataset_utils import load_dataset, create_client_datasets
  776. from federated_learning.utils.model_utils import set_random_seeds
  778. num_rounds = 2 if dry_run else 25
  780. set_all_seeds(seed)
  782. configure_for_dataset(
  783. 'ALZHEIMER', num_clients=10,
  784. non_iid_config={'enable': True, 'type': 'dirichlet', 'alpha': 0.1},
  785. aggregation_method='fedbn_fedprox'
  786. )
  787. cfg_mod.RANDOM_SEED = seed
  788. cfg_mod.GLOBAL_EPOCHS = num_rounds
  789. cfg_mod.FRACTION_MALICIOUS = 0.4
  790. cfg_mod.NUM_MALICIOUS = 4
  791. cfg_mod.BATCH_SIZE = 16
  792. cfg_mod.LR = 1e-4
  793. cfg_mod.WEIGHT_DECAY = 5e-5
  794. cfg_mod.ENABLE_VAE = True
  795. cfg_mod.ENABLE_SHAPLEY = True
  796. cfg_mod.ENABLE_DUAL_ATTENTION = True
  797. cfg_mod.RL_AGGREGATION_METHOD = 'hybrid'
  798. cfg_mod.RL_WARMUP_ROUNDS = 5
  799. cfg_mod.RL_RAMP_UP_ROUNDS = 10
  800. cfg_mod.AGGREGATION_METHOD = 'fedbn_fedprox'
  801. cfg_mod.GRADIENT_COMBINATION_METHOD = 'fedbn_fedprox'
  802. cfg_mod.SCALING_FACTOR = 20.0
  803. _sync_config_to_modules()
  805. set_random_seeds(seed)
  807. try:
  808. train_dataset, test_dataset = load_dataset()
  809. root_loader = torch.utils.data.DataLoader(
  810. train_dataset, batch_size=cfg_mod.BATCH_SIZE, shuffle=True, num_workers=0)
  812. server = Server()
  813. server.set_datasets(root_loader, test_dataset)
  814. server._pretrain_global_model()
  816. _, client_datasets = create_client_datasets(
  817. train_dataset=train_dataset, num_clients=10, iid=False, alpha=0.1)
  819. malicious_indices = np.random.choice(10, 4, replace=False)
  820. clients = []
  821. client_is_malicious = {}
  822. for i in range(10):
  823. is_mal = int(i) in malicious_indices.tolist()
  824. client_is_malicious[i] = is_mal
  825. c = Client(client_id=i, dataset=client_datasets[i], is_malicious=is_mal)
  826. if is_mal:
  827. c.set_attack_parameters(
  828. attack_type='scaling_attack',
  829. scaling_factor=20.0,
  830. partial_percent=cfg_mod.PARTIAL_SCALING_PERCENT,
  831. noise_factor=cfg_mod.NOISE_FACTOR,
  832. flip_probability=cfg_mod.FLIP_PROBABILITY,
  833. )
  834. clients.append(c)
  835. server.add_clients(clients)
  837. root_gradients = server._collect_root_gradients()
  838. server.root_gradients = root_gradients # enables root-cosine & sign-consistency features
  839. server.vae = server.train_vae(root_gradients, vae_epochs=cfg_mod.VAE_EPOCHS)
  841. test_loader = torch.utils.data.DataLoader(
  842. test_dataset, batch_size=cfg_mod.BATCH_SIZE, shuffle=False, num_workers=0)
  843. server.test_loader = test_loader
  845. _, round_metrics = server.train(num_rounds=cfg_mod.GLOBAL_EPOCHS)
  846. final_acc = server.evaluate_model()
  847. logger.info(f" Final accuracy: {final_acc*100:.2f}%")
  849. # ---- Extract trust scores and Shapley values ----
  850. trust_data = [] # list of dicts: round, client_id, is_malicious, trust_score, shapley_value
  852. for r_idx, rd in round_metrics.items():
  853. trust_scores = rd.get('trust_scores', {})
  854. features_dict = rd.get('features', {}) # features[client_id] = [f0..f5]
  856. for client_id in range(10):
  857. ts = trust_scores.get(client_id, None)
  858. if ts is None:
  859. continue
  860. shap = None
  861. if client_id in features_dict:
  862. feats = features_dict[client_id]
  863. if isinstance(feats, list) and len(feats) >= 6:
  864. shap = float(feats[5])
  866. trust_data.append({
  867. 'round': int(r_idx) + 1,
  868. 'client_id': client_id,
  869. 'is_malicious': int(client_is_malicious.get(client_id, False)),
  870. 'trust_score': float(ts),
  871. 'shapley_value': shap,
  872. })
  874. if not trust_data:
  875. logger.warning(" No trust scores found in round_metrics. Skipping plots.")
  876. return {}
  878. # Save raw CSV
  879. csv_path = os.path.join(RESULTS_DIR, 'exp3_trust_scores.csv')
  880. fields = ['round', 'client_id', 'is_malicious', 'trust_score', 'shapley_value']
  881. with open(csv_path, 'w', newline='') as f:
  882. w = csv.DictWriter(f, fieldnames=fields, extrasaction='ignore')
  883. w.writeheader()
  884. w.writerows(trust_data)
  885. logger.info(f" Saved trust data CSV → {csv_path}")
  887. # ---- Build per-client time series ----
  888. rounds_list = sorted(set(d['round'] for d in trust_data))
  889. client_ts = {} # client_id → {round: trust_score}
  890. client_shap = {} # client_id → [shapley values across rounds]
  892. for d in trust_data:
  893. cid = d['client_id']
  894. if cid not in client_ts:
  895. client_ts[cid] = {}
  896. client_shap[cid] = []
  897. client_ts[cid][d['round']] = d['trust_score']
  898. if d['shapley_value'] is not None:
  899. client_shap[cid].append(d['shapley_value'])
  901. # Benign/malicious split
  902. benign_ids = [cid for cid, m in client_is_malicious.items() if not m]
  903. malicious_ids = [cid for cid, m in client_is_malicious.items() if m]
  905. # ---- Option A: Trust Score Time Series ----
  906. fig_a, ax_a = plt.subplots(figsize=(10, 5))
  907. for cid in benign_ids:
  908. ts_vals = [client_ts[cid].get(r, np.nan) for r in rounds_list]
  909. ax_a.plot(rounds_list, ts_vals, color='#2166ac', linewidth=1.5,
  910. alpha=0.75, label='Benign' if cid == benign_ids[0] else '')
  911. for cid in malicious_ids:
  912. ts_vals = [client_ts[cid].get(r, np.nan) for r in rounds_list]
  913. ax_a.plot(rounds_list, ts_vals, color='#d6604d', linewidth=1.5,
  914. linestyle='--', alpha=0.85,
  915. label='Malicious' if cid == malicious_ids[0] else '')
  917. patch_b = mpatches.Patch(color='#2166ac', label='Benign clients')
  918. patch_m = mpatches.Patch(color='#d6604d', label='Malicious clients')
  919. ax_a.legend(handles=[patch_b, patch_m], fontsize=11)
  920. ax_a.set_xlabel('Round', fontsize=12)
  921. ax_a.set_ylabel('Trust Score', fontsize=12)
  922. ax_a.set_ylim(-0.05, 1.05)
  923. ax_a.set_title('Trust Score Time Series: Benign vs. Malicious Clients\n'
  924. '(Alzheimer MRI, Scaling ×20, 40% Malicious, Seed=42)', fontsize=12)
  925. ax_a.grid(True, alpha=0.3)
  926. fig_a.tight_layout()
  927. fig_a_path = os.path.join(RESULTS_DIR, 'exp3_trust_timeseries.png')
  928. fig_a.savefig(fig_a_path, dpi=300, bbox_inches='tight')
  929. plt.close(fig_a)
  930. logger.success(f" Saved Option A (time series) → {fig_a_path}")
  932. # ---- Option B: Trust Score Box Plot ----
  933. benign_scores = [client_ts[cid].get(r, np.nan)
  934. for cid in benign_ids for r in rounds_list
  935. if not np.isnan(client_ts[cid].get(r, np.nan))]
  936. malicious_scores = [client_ts[cid].get(r, np.nan)
  937. for cid in malicious_ids for r in rounds_list
  938. if not np.isnan(client_ts[cid].get(r, np.nan))]
  940. if benign_scores and malicious_scores:
  941. fig_b, ax_b = plt.subplots(figsize=(6, 5))
  942. bp = ax_b.boxplot(
  943. [benign_scores, malicious_scores],
  944. labels=['Benign Clients', 'Malicious Clients'],
  945. patch_artist=True,
  946. medianprops=dict(color='black', linewidth=2),
  947. )
  948. bp['boxes'][0].set_facecolor('#a6cee3')
  949. if len(bp['boxes']) > 1:
  950. bp['boxes'][1].set_facecolor('#fb9a99')
  951. ax_b.set_ylabel('Average Trust Score', fontsize=12)
  952. ax_b.set_title('Trust Score Distribution\n'
  953. '(Benign vs. Malicious Clients)', fontsize=12)
  954. ax_b.grid(True, axis='y', alpha=0.3)
  955. fig_b.tight_layout()
  956. fig_b_path = os.path.join(RESULTS_DIR, 'exp3_trust_boxplot.png')
  957. fig_b.savefig(fig_b_path, dpi=300, bbox_inches='tight')
  958. plt.close(fig_b)
  959. logger.success(f" Saved Option B (box plot) → {fig_b_path}")
  961. # ---- Option C: Shapley Value Distribution (violin) ----
  962. benign_shap = [v for cid in benign_ids for v in client_shap.get(cid, [])]
  963. malicious_shap = [v for cid in malicious_ids for v in client_shap.get(cid, [])]
  965. if benign_shap and malicious_shap:
  966. fig_c, ax_c = plt.subplots(figsize=(6, 5))
  967. parts = ax_c.violinplot(
  968. [benign_shap, malicious_shap],
  969. positions=[1, 2],
  970. showmedians=True,
  971. )
  972. for pc, color in zip(parts['bodies'], ['#a6cee3', '#fb9a99']):
  973. pc.set_facecolor(color)
  974. pc.set_alpha(0.75)
  975. ax_c.set_xticks([1, 2])
  976. ax_c.set_xticklabels(['Benign Clients', 'Malicious Clients'])
  977. ax_c.set_ylabel('Shapley Value', fontsize=12)
  978. ax_c.set_title('Shapley Value Distribution\n'
  979. '(Benign vs. Malicious Clients)', fontsize=12)
  980. ax_c.grid(True, axis='y', alpha=0.3)
  981. fig_c.tight_layout()
  982. fig_c_path = os.path.join(RESULTS_DIR, 'exp3_shapley_violin.png')
  983. fig_c.savefig(fig_c_path, dpi=300, bbox_inches='tight')
  984. plt.close(fig_c)
  985. logger.success(f" Saved Option C (Shapley violin) → {fig_c_path}")
  987. logger.info('\nExperiment 3 complete.')
  988. return {'trust_data': trust_data, 'final_accuracy': float(final_acc)}
  990. except Exception as exc:
  991. logger.error(f" Experiment 3 FAILED: {str(exc)[:200]}")
  992. traceback.print_exc()
  993. return {'status': 'failed', 'error': str(exc)}
  996. # ===========================================================================
  997. # EXPERIMENT 4 — OPTIMIZER COMPARISON UNDER ADVERSARIAL CONDITIONS
  998. # ===========================================================================
  1000. # Optimizers to compare, in priority order (run as many as time allows)
  1001. EXP4_OPTIMIZERS = [
  1002. {'name': 'FedAvg', 'method': 'fedavg', 'optigradtrust': False},
  1003. {'name': 'FedBN', 'method': 'fedbn', 'optigradtrust': False},
  1004. {'name': 'FedBN-P', 'method': 'fedbn_fedprox', 'optigradtrust': True}, # ours
  1005. {'name': 'FedProx', 'method': 'fedprox', 'optigradtrust': False},
  1006. {'name': 'FedNova', 'method': 'fednova', 'optigradtrust': False},
  1007. {'name': 'SCAFFOLD', 'method': 'scaffold', 'optigradtrust': False},
  1008. {'name': 'FedDWA', 'method': 'feddwa', 'optigradtrust': False},
  1009. {'name': 'FedADMM', 'method': 'fedadmm', 'optigradtrust': False},
  1010. ]
  1013. def _run_exp4_single_optimizer(opt_cfg, seed, num_rounds):
  1014. """Run one optimizer for Experiment 4 (adversarial conditions)."""
  1015. import federated_learning.config.config as cfg_mod
  1016. from federated_learning.training.server import Server
  1017. from federated_learning.training.client import Client
  1018. from federated_learning.data.dataset_utils import load_dataset, create_client_datasets
  1019. from federated_learning.utils.model_utils import set_random_seeds
  1021. opt_name = opt_cfg['name']
  1022. opt_method = opt_cfg['method']
  1023. use_trust = opt_cfg['optigradtrust']
  1025. logger.info(f" [{opt_name}] seed={seed}")
  1027. set_all_seeds(seed)
  1029. # Configure
  1030. configure_for_dataset(
  1031. 'ALZHEIMER', num_clients=10,
  1032. non_iid_config={'enable': False, 'type': 'iid', 'alpha': None},
  1033. aggregation_method=opt_method
  1034. )
  1035. cfg_mod.RANDOM_SEED = seed
  1036. cfg_mod.GLOBAL_EPOCHS = num_rounds
  1037. cfg_mod.FRACTION_MALICIOUS = 0.3
  1038. cfg_mod.NUM_MALICIOUS = 3
  1039. cfg_mod.BATCH_SIZE = 16
  1040. cfg_mod.LR = 1e-4
  1041. cfg_mod.WEIGHT_DECAY = 5e-5
  1042. cfg_mod.SCALING_FACTOR = 10.0
  1044. # For FedBN-P (our method), enable full OptiGradTrust trust mechanism
  1045. # For others, use their plain aggregation (baseline mode — no trust)
  1046. if use_trust:
  1047. cfg_mod.ENABLE_VAE = True
  1048. cfg_mod.ENABLE_SHAPLEY = True
  1049. cfg_mod.ENABLE_DUAL_ATTENTION = True
  1050. cfg_mod.RL_AGGREGATION_METHOD = 'hybrid'
  1051. cfg_mod.RL_WARMUP_ROUNDS = 5
  1052. cfg_mod.RL_RAMP_UP_ROUNDS = 10
  1053. cfg_mod.AGGREGATION_METHOD = opt_method
  1054. cfg_mod.GRADIENT_COMBINATION_METHOD = opt_method
  1055. # else: configure_for_dataset already set baseline mode (VAE/Shapley/DA disabled)
  1057. _sync_config_to_modules()
  1058. set_random_seeds(seed)
  1059. start_t = time.time()
  1061. try:
  1062. train_dataset, test_dataset = load_dataset()
  1063. root_loader = torch.utils.data.DataLoader(
  1064. train_dataset, batch_size=cfg_mod.BATCH_SIZE, shuffle=True, num_workers=0)
  1066. server = Server()
  1067. server.set_datasets(root_loader, test_dataset)
  1068. server._pretrain_global_model()
  1070. _, client_datasets = create_client_datasets(
  1071. train_dataset=train_dataset, num_clients=10, iid=True, alpha=None)
  1073. malicious_indices = np.random.choice(10, 3, replace=False)
  1074. clients = []
  1075. for i in range(10):
  1076. is_mal = int(i) in malicious_indices.tolist()
  1077. c = Client(client_id=i, dataset=client_datasets[i], is_malicious=is_mal)
  1078. if is_mal:
  1079. c.set_attack_parameters(
  1080. attack_type='scaling_attack',
  1081. scaling_factor=10.0,
  1082. partial_percent=cfg_mod.PARTIAL_SCALING_PERCENT,
  1083. noise_factor=cfg_mod.NOISE_FACTOR,
  1084. flip_probability=cfg_mod.FLIP_PROBABILITY,
  1085. )
  1086. clients.append(c)
  1087. server.add_clients(clients)
  1089. root_gradients = server._collect_root_gradients()
  1090. server.root_gradients = root_gradients # enables root-cosine & sign-consistency features
  1091. if getattr(cfg_mod, 'ENABLE_VAE', False):
  1092. server.vae = server.train_vae(root_gradients, vae_epochs=cfg_mod.VAE_EPOCHS)
  1093. else:
  1094. server.vae = None
  1096. test_loader = torch.utils.data.DataLoader(
  1097. test_dataset, batch_size=cfg_mod.BATCH_SIZE, shuffle=False, num_workers=0)
  1098. server.test_loader = test_loader
  1100. _, round_metrics = server.train(num_rounds=cfg_mod.GLOBAL_EPOCHS)
  1101. final_acc = server.evaluate_model()
  1103. # Per-round accuracy
  1104. per_round_acc = {}
  1105. for r_idx, rd in round_metrics.items():
  1106. per_round_acc[int(r_idx) + 1] = float(rd.get('test_accuracy', 0.0))
  1108. result = {
  1109. 'optimizer_name': opt_name,
  1110. 'method': opt_method,
  1111. 'seed': seed,
  1112. 'final_accuracy': float(final_acc),
  1113. 'per_round_acc': per_round_acc,
  1114. 'total_time': time.time() - start_t,
  1115. 'status': 'completed',
  1116. }
  1117. logger.success(f" → Final Acc={final_acc*100:.2f}%")
  1118. return result
  1120. except Exception as exc:
  1121. logger.error(f" → FAILED: {str(exc)[:120]}")
  1122. traceback.print_exc()
  1123. return {
  1124. 'optimizer_name': opt_name,
  1125. 'method': opt_method,
  1126. 'seed': seed,
  1127. 'status': 'failed',
  1128. 'error': str(exc),
  1129. 'total_time': time.time() - start_t,
  1130. }
  1133. def run_exp4_optimizer_adversarial(seed=42, dry_run=False, n_optimizers=4):
  1134. """
  1135. Experiment 4: Optimizer comparison under adversarial conditions.
  1136. IID, 30% malicious, scaling x10, 25 rounds, seed=42.
  1138. Generates:
  1139. - Summary table (CSV): final accuracy per optimizer
  1140. - Per-round CSV: accuracy vs round (for convergence figure)
  1141. - Convergence figure (PNG)
  1142. """
  1143. logger.info('=' * 70)
  1144. logger.info('EXPERIMENT 4: OPTIMIZER COMPARISON UNDER ADVERSARIAL CONDITIONS')
  1145. logger.info(' Dataset: Alzheimer MRI | IID | Malicious: 30% | Scaling x10')
  1146. logger.info(' Compares: FedAvg, FedBN, FedBN-P, FedProx [+ FedNova, SCAFFOLD, FedDWA, FedADMM]')
  1147. logger.info('=' * 70)
  1149. num_rounds = 2 if dry_run else 25
  1150. # Limit to n_optimizers (priority order); if dry_run, just top 3
  1151. opts_to_run = EXP4_OPTIMIZERS[:3] if dry_run else EXP4_OPTIMIZERS[:n_optimizers]
  1153. all_results = []
  1154. per_round_rows = []
  1156. for opt_cfg in opts_to_run:
  1157. logger.info(f"\n Optimizer: {opt_cfg['name']}")
  1158. r = _run_exp4_single_optimizer(opt_cfg, seed, num_rounds)
  1159. all_results.append(r)
  1161. if r['status'] == 'completed':
  1162. for round_num, acc in r['per_round_acc'].items():
  1163. per_round_rows.append({
  1164. 'round': round_num,
  1165. 'optimizer': opt_cfg['name'],
  1166. 'accuracy': acc,
  1167. 'is_our_method': int(opt_cfg['optigradtrust']),
  1168. })
  1170. # ---- Per-round CSV ----
  1171. csv_pr_path = os.path.join(RESULTS_DIR, 'exp4_optimizer_adversarial_per_round.csv')
  1172. if per_round_rows:
  1173. with open(csv_pr_path, 'w', newline='') as f:
  1174. w = csv.DictWriter(f, fieldnames=['round', 'optimizer', 'accuracy', 'is_our_method'])
  1175. w.writeheader()
  1176. w.writerows(per_round_rows)
  1177. logger.info(f"\n Saved per-round CSV → {csv_pr_path}")
  1179. # ---- Summary table ----
  1180. logger.info('\n' + '=' * 70)
  1181. logger.info('EXPERIMENT 4 SUMMARY: Optimizer Final Accuracy under Adversarial Conditions')
  1182. logger.info(f"{'Optimizer':<12} {'Final Acc (%)':>14} {'Defense':>10}")
  1183. logger.info('-' * 50)
  1184. summary_rows = []
  1185. for r in all_results:
  1186. if r['status'] != 'completed':
  1187. continue
  1188. has_trust = next((o['optigradtrust'] for o in opts_to_run
  1189. if o['name'] == r['optimizer_name']), False)
  1190. defense_str = 'OptiGradTrust' if has_trust else 'None'
  1191. logger.info(f" {r['optimizer_name']:<10} {r['final_accuracy']*100:>14.2f} {defense_str:>10}")
  1192. summary_rows.append({
  1193. 'optimizer': r['optimizer_name'],
  1194. 'method': r['method'],
  1195. 'final_accuracy': r['final_accuracy'],
  1196. 'has_defense': int(has_trust),
  1197. })
  1198. logger.info('=' * 70)
  1200. csv_sum_path = os.path.join(RESULTS_DIR, 'exp4_optimizer_adversarial_summary.csv')
  1201. if summary_rows:
  1202. with open(csv_sum_path, 'w', newline='') as f:
  1203. w = csv.DictWriter(f, fieldnames=list(summary_rows[0].keys()))
  1204. w.writeheader()
  1205. w.writerows(summary_rows)
  1206. logger.info(f" Saved summary CSV → {csv_sum_path}")
  1208. json_path = os.path.join(RESULTS_DIR, 'exp4_optimizer_adversarial_results.json')
  1209. with open(json_path, 'w') as f:
  1210. json.dump(all_results, f, indent=2, default=str)
  1211. logger.info(f" Saved JSON → {json_path}")
  1213. # ---- Convergence figure ----
  1214. if per_round_rows:
  1215. try:
  1216. opt_names = list(dict.fromkeys(r['optimizer'] for r in per_round_rows))
  1217. colors = plt.cm.tab10(np.linspace(0, 1, len(opt_names)))
  1218. fig, ax = plt.subplots(figsize=(10, 5))
  1219. for opt_name, color in zip(opt_names, colors):
  1220. rows = [(r['round'], r['accuracy'])
  1221. for r in per_round_rows if r['optimizer'] == opt_name]
  1222. if not rows:
  1223. continue
  1224. rows.sort(key=lambda x: x[0])
  1225. xs = [r[0] for r in rows]
  1226. ys = [r[1] * 100 for r in rows]
  1227. lw = 2.5 if opt_name == 'FedBN-P' else 1.5
  1228. ls = '-' if opt_name == 'FedBN-P' else '--'
  1229. ax.plot(xs, ys, label=opt_name, color=color, linewidth=lw, linestyle=ls)
  1231. ax.set_xlabel('Round', fontsize=12)
  1232. ax.set_ylabel('Test Accuracy (%)', fontsize=12)
  1233. ax.set_title('Optimizer Comparison under Adversarial Conditions\n'
  1234. '(Alzheimer MRI, IID, 30% Malicious, Scaling ×10)', fontsize=12)
  1235. ax.legend(fontsize=10)
  1236. ax.grid(True, alpha=0.3)
  1237. fig.tight_layout()
  1238. fig_path = os.path.join(RESULTS_DIR, 'exp4_optimizer_adversarial_convergence.png')
  1239. fig.savefig(fig_path, dpi=300, bbox_inches='tight')
  1240. plt.close(fig)
  1241. logger.success(f" Saved convergence figure → {fig_path}")
  1242. except Exception as exc:
  1243. logger.warning(f" Could not generate convergence figure: {exc}")
  1245. logger.info('\nExperiment 4 complete.')
  1246. return all_results
  1249. # ===========================================================================
  1250. # MAIN
  1251. # ===========================================================================
  1253. def main():
  1254. parser = argparse.ArgumentParser(
  1255. description='OptiGradTrust Round-2 Revision Experiments',
  1256. formatter_class=argparse.RawDescriptionHelpFormatter,
  1257. epilog="""
  1258. Priority order (run in this order if time is limited):
  1259. 1. exp2 — Dynamic attack / RL justification [NON-NEGOTIABLE]
  1260. 2. exp1a — Noise ablation / VAE validation [CRITICAL]
  1261. 3. exp3 — Trust visualization [REQUIRED]
  1262. 4. exp1b — Sign-flip ablation [CRITICAL]
  1263. 5. exp4 — Optimizer adversarial comparison [RECOMMENDED]
  1265. Examples:
  1266. python run_r2_experiments.py --experiment exp2 --seeds 42 123 456
  1267. python run_r2_experiments.py --experiment exp1a --seeds 42 123 456 789 1024
  1268. python run_r2_experiments.py --experiment all --seeds 42
  1269. python run_r2_experiments.py --experiment exp2 --dry-run
  1270. """
  1271. )
  1272. parser.add_argument(
  1273. '--experiment',
  1274. choices=['exp1a', 'exp1b', 'exp2', 'exp3', 'exp4', 'all'],
  1275. default='all',
  1276. help='Which experiment to run'
  1277. )
  1278. parser.add_argument(
  1279. '--seeds', type=int, nargs='+',
  1280. default=None,
  1281. help='Random seeds (default: single seed=42 for most; 42 123 456 for exp2)'
  1282. )
  1283. parser.add_argument(
  1284. '--dry-run', action='store_true',
  1285. help='Quick 2-3 round sanity check (do not use for real results)'
  1286. )
  1287. parser.add_argument(
  1288. '--n-optimizers', type=int, default=4,
  1289. help='Number of optimizers to run in Experiment 4 (1-8, default 4)'
  1290. )
  1291. args = parser.parse_args()
  1293. logger.info('=' * 70)
  1294. logger.info('OptiGradTrust — Round 2 Revision Experiments')
  1295. logger.info(f'Experiment: {args.experiment} | Dry-run: {args.dry_run}')
  1296. logger.info(f'Seeds: {args.seeds}')
  1297. logger.info(f'Output dir: {RESULTS_DIR}')
  1298. logger.info('=' * 70)
  1300. exp = args.experiment
  1301. dry = args.dry_run
  1303. if exp in ('exp1a', 'all'):
  1304. seeds = args.seeds or ([42] if dry else [42])
  1305. run_exp1a_noise_ablation(seeds=seeds, dry_run=dry)
  1307. if exp in ('exp1b', 'all'):
  1308. seeds = args.seeds or ([42] if dry else [42])
  1309. run_exp1b_signflip_ablation(seeds=seeds, dry_run=dry)
  1311. if exp in ('exp2', 'all'):
  1312. seeds = args.seeds or ([42] if dry else [42, 123, 456])
  1313. run_exp2_dynamic_attack(seeds=seeds, dry_run=dry)
  1315. if exp in ('exp3', 'all'):
  1316. seed = (args.seeds[0] if args.seeds else 42)
  1317. run_exp3_trust_visualization(seed=seed, dry_run=dry)
  1319. if exp in ('exp4', 'all'):
  1320. seed = (args.seeds[0] if args.seeds else 42)
  1321. run_exp4_optimizer_adversarial(seed=seed, dry_run=dry,
  1322. n_optimizers=args.n_optimizers)
  1324. logger.info('\n' + '=' * 70)
  1325. logger.info('All requested R2 experiments finished.')
  1326. logger.info(f'Results saved in: {RESULTS_DIR}')
  1327. logger.info('=' * 70)
  1330. if __name__ == '__main__':
  1331. main()

run_r2_experiments.py at commit 92e325e, under MIT · at the source

Overview

Authors: Mohammad Karami1, Hamed Kebriaei1, Fatemeh Ghassemi1, Hamid Azadegan2
ORCID iDs: Mohammad Karami
  1. School of Electrical and Computer Engineering, University of Tehran, Tehran, 1439957131 Iran
  2. School of Computer Engineering, Iran University of Science and Technology (IUST), Tehran, 1684613114 Iran
Institutions: University of Tehran (Iran); Iran University of Science and Technology (Iran)
Journal: Scientific reports, volume 16, issue 1, article 25604
Dates: received 25 February 2026; accepted 27 May 2026; published online 4 June 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1038/s41598-026-55855-5 · PMID 42243446 · PMCID PMC13478148 · OpenAlex W4414921340
Open access: gold, a free copy (OpenAlex)
Preprint: arxiv:2507.23638
Status: code verified
Categories: structural MRI / diffusion (modality), human (organism), Alzheimer's / dementia (population), cellular / molecular (subfield)
Methods: Statistics, Machine learning
Keywords: Federated learning, Byzantine robustness, Trust-aware aggregation, Non-IID data, Brain MRI, Alzheimer’s disease, Mathematics and computing, Neuroscience
MeSH: Brain*, Image Processing, Computer-Assisted*, Magnetic Resonance Imaging*, Algorithms, Federated Learning, Humans, Trust (* major topic)
Topic: Privacy-Preserving Technologies in Data (Artificial Intelligence, Computer Science), according to OpenAlex
Citations: not cited yet (Europe PMC); 58 references in the paper

Abstract

Federated learning enables collaborative training across institutions without centralizing patient data, but remains vulnerable to malicious clients and severe non-IID data heterogeneity. We propose a trust-aware federated learning framework for brain MRI that combines multi-signal gradient fingerprinting with adaptive aggregation to achieve Byzantine robustness. Each client update is characterized by a six-dimensional fingerprint (variational-autoencoder reconstruction error, cosine similarity to a server reference, peer similarity, gradient norm, sign consistency, and Monte Carlo Shapley contribution). A dual-attention module and a reinforcement-learning controller map these signals into trust weights and integrate with FedBN-P (Federated Batch Normalization with Proximal regularization), an optimizer co-designed for stability under heterogeneous and adversarial conditions. We evaluate on MNIST, CIFAR-10, Alzheimer’s MRI, and the OASIS brain-MRI cohort (approximately 87 test samples, used strictly as proof-of-concept) under both standard and strengthened threat models (up to 40% malicious clients). Attack-specific ablation confirms a defense-in-depth design: VAE fingerprinting is the primary noise-attack defense (3.60 pp accuracy drop upon removal), Shapley values safeguard accuracy under scaling (10.16 pp drop), and reinforcement learning improves detection consistency under dynamic attack schedules. Three-seed paired-test validation further shows detection F1 outperforms FLTrust by up to 44 pp on Non-IID Gaussian noise; a white-box adaptive attacker degrades the detector but not model accuracy, confirming the layered design. End-to-end wall-clock overhead is + 8.8% over FedAvg with identical communication volume. The framework achieves F1 above 0.98 for gradient-scaling attacks while preserving accuracy under magnitude-preserving attacks where explicit detection remains limited. Multi-site validation on larger federated cohorts (e.g., ADNI, UK Biobank, FeTS) is required before any clinical-deployment claim can be made.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repository

Its files are read in the Code ↔ Paper reader above, with 32 matches between paragraphs and lines of code.

mohammadkarami79/OptiGradTrust

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 92e325ee5db6f8228f8e7daccd2abcf74472b94c, 20 April 2026
Languages: Python (52)
Size: 78 files, 52 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, license file, environment (requirements.txt, setup.py, federated_learning/requirements.txt)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: PyTorch (40 files), NumPy (32 files), Matplotlib (8 files), pandas (4 files), Pillow (3 files), SciPy (3 files), scikit-learn (2 files), seaborn (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
54 files
At the source: github.com/mohammadkarami79/OptiGradTrust

Code availability

The code implementing OptiGradTrust (training loops, six-dimensional fingerprinting, dual-attention, DDQN trust controller, FedBN-P optimizer, and all evaluation scripts) is publicly available at https://github.com/mohammadkarami79/OptiGradTrust. The implementation uses Python 3.9, PyTorch 1.12 (and tested up to PyTorch 2.7 on the R3 experiments), and standard scientific Python libraries (NumPy, SciPy, Matplotlib). Reproducibility commitment. The repository includes: (i) comprehensive documentation and configuration files for every experiment reported in the paper (original-configuration runs, strengthened-configuration runs, and the six R3 additional analyses described in Section 2.14); (ii) deterministic seed lists ( for R3, plus for the strengthened-configuration multi-seed runs) so that every reported number can be reproduced; (iii) the exact data splits used for OASIS, Alzheimer’s MRI, MNIST, and CIFAR-10; (iv) trained VAE checkpoints for the Alzheimer’s MRI benchmark; (v) per-experiment raw CSV / JSON artifacts for the R3 analyses; and (vi) an environment.yml pinning all package versions. Upon acceptance we will additionally release a Dockerfile encapsulating the full software stack.

Reproduced under the paper's license (CC BY), from the paper cited above.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 52 scripts, each with its path and the digest of its content;
  • 32 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

Datasets cited

Data availability

This study used only publicly available, de-identified datasets. The MNIST dataset was accessed via the TensorFlow/Keras canonical release (https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz). CIFAR-10 is available at https://www.cs.toronto.edu/~kriz/cifar.html. The Alzheimer’s MRI dataset is a public Kaggle resource (https://www.kaggle.com/datasets/lukechugh/best-alzheimer-mri-dataset-99-accuracy). The OASIS (Open Access Series of Imaging Studies) cross-sectional MRI dataset is available at https://www.oasis-brains.org/. All datasets were used in accordance with their respective licenses. No new human data were collected; OASIS data are de‑identified and released under open-access terms.

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 4 authors, 8 keywords, 7 MeSH terms, 8 references.

Cite

This paper

Karami, M., Kebriaei, H., Ghassemi, F., & Azadegan, H. (2026). Byzantine robust federated learning for heterogeneous brain MRI using multisignal gradient fingerprinting and adaptive trust aggregation. Scientific reports, 16(1), 25604. https://doi.org/10.1038/s41598-026-55855-5

BibTeX

@article{karami2026byzantine,
author = {Karami, Mohammad and Kebriaei, Hamed and Ghassemi, Fatemeh and Azadegan, Hamid},
title = {{Byzantine robust federated learning for heterogeneous brain MRI using multisignal gradient fingerprinting and adaptive trust aggregation}},
journal = {Scientific reports},
year = {2026},
month = jun,
volume = {16},
number = {1},
pages = {25604},
publisher = {Nature Publishing Group},
issn = {2045-2322},
doi = {10.1038/s41598-026-55855-5},
url = {https://doi.org/10.1038/s41598-026-55855-5},
pmid = {42243446},
pmcid = {PMC13478148}
}

RIS

TY - JOUR
AU - Karami, Mohammad
AU - Kebriaei, Hamed
AU - Ghassemi, Fatemeh
AU - Azadegan, Hamid
TI - Byzantine robust federated learning for heterogeneous brain MRI using multisignal gradient fingerprinting and adaptive trust aggregation
T2 - Scientific reports
J2 - Sci Rep
PY - 2026
DA - 2026/06/04
VL - 16
IS - 1
SP - 25604
SN - 2045-2322
PB - Nature Publishing Group
DO - 10.1038/s41598-026-55855-5
UR - https://doi.org/10.1038/s41598-026-55855-5
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41598-026-55855-5",
"type": "article-journal",
"title": "Byzantine robust federated learning for heterogeneous brain MRI using multisignal gradient fingerprinting and adaptive trust aggregation",
"container-title": "Scientific reports",
"author": [
{
"family": "Karami",
"given": "Mohammad"
},
{
"family": "Kebriaei",
"given": "Hamed"
},
{
"family": "Ghassemi",
"given": "Fatemeh"
},
{
"family": "Azadegan",
"given": "Hamid"
}
],
"container-title-short": "Sci Rep",
"volume": "16",
"issue": "1",
"page": "25604",
"DOI": "10.1038/s41598-026-55855-5",
"PMID": "42243446",
"PMCID": "PMC13478148",
"ISSN": "2045-2322",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41598-026-55855-5",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
4
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1002/alz.71649 [code]
Postmortem brain MRI reveals differential associations of subcortical and limbic volumes with cortical thinning and neurodegenerative pathologies.
Journal: Alzheimer's & dementia : the journal of the Alzheimer's Association
In common: Pillow, PyTorch, seaborn, 5 other tools, Alzheimer's / dementia, structural MRI / diffusion, cellular / molecular
[2] doi:10.64898/2026.08.18.26360725 [code]
Temporal pole blurring in hippocampal sclerosis reflects seizure-disrupted myelination
Journal: medRxiv (preprint)
In common: Pillow, PyTorch, seaborn, 5 other tools, structural MRI / diffusion, cellular / molecular
[3] doi:10.3390/jimaging12070276 [code]
Hyperelastic Regularization for Near-Diffeomorphic Transformer-Based Brain MRI Registration.
Journal: Journal of imaging
In common: Pillow, PyTorch, scikit-learn, 4 other tools, structural MRI / diffusion, 1 reference
[4] doi:10.1038/s41467-026-76837-1 [code]
Drug screen and machine learning predict neuroprotective agents in a preclinical human model of childhood dementia.
Journal: Nature communications
In common: Pillow, PyTorch, seaborn, 5 other tools, Alzheimer's / dementia
[5] doi:10.1093/bioinformatics/btag540 [code]
Deciphering spatial heterogeneity by multimodal spatial transcriptomics modelling with SpatialModal.
Journal: Bioinformatics (Oxford, England)
In common: Pillow, PyTorch, seaborn, 5 other tools, Alzheimer's / dementia
[6] doi:10.1186/s13244-026-02365-7 [code]
Super-resolution MRI and 2.5D deep learning for intratumoral-peritumoral radiomics in preoperative prediction of rectal cancer perineural invasion.
Journal: Insights into imaging
In common: Pillow, PyTorch, seaborn, 5 other tools, structural MRI / diffusion
[7] doi:10.1371/journal.pcbi.1014555 [code]
Body surface potential driven personalisation of electrophysiological digital twins in hypertrophic cardiomyopathy.
Journal: PLoS computational biology
In common: Pillow, PyTorch, seaborn, 5 other tools, structural MRI / diffusion
[8] doi:10.1007/s00234-026-04103-8 [code]
Enhanced detection of subtle cortical abnormalities in focal epilepsy using 7 T MRI surface-based models and graph neural networks.
Journal: Neuroradiology
In common: Pillow, PyTorch, seaborn, 5 other tools, structural MRI / diffusion
[9] doi:10.1093/braincomms/fcag253 [code]
Disease detection and classification in temporal lobe epilepsy: step-wise versus simultaneous AI decision models in a multisite neuroimaging study.
Journal: Brain communications
In common: Pillow, PyTorch, seaborn, 5 other tools, structural MRI / diffusion
[10] doi:10.1002/ana.78203 [code]
AI-Driven Mapping of Seizure Spread Patterns.
Journal: Annals of neurology
In common: Pillow, PyTorch, seaborn, 5 other tools, structural MRI / diffusion

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.