Federated learning voor militaire AI op verspreide classificatiedata

De centrale paradox van militaire AI-training is dat de data die de operationele prestaties van een model het meest zou verbeteren, precies de data is die niet verplaatst mag worden. Geclassificeerde sensorlogs, ISR-beelden van actieve theaters, elektronische order-of-battle-records en datasets van geallieerde partners bestaan achter compartimentsgrenzen die conventioneel gecentraliseerd trainen onmogelijk maken. Federated learning lost deze paradox op door het trainingsparadigma om te keren: in plaats van data naar het model te verplaatsen, gaat het model naar de data. Elke deelnemende organisatie traint lokaal op zijn eigen geclassificeerde corpus en deelt alleen gradiëntupdates — wiskundige afgeleiden die het globale model verbeteren zonder de onderliggende trainingsamples prijs te geven. Dit artikel behandelt de volledige technische stack voor het implementeren van federated learning in defensieomgevingen, van federatietopologieselectie via differentiële-privacykalibratie, secure aggregation, asynchrone tactische werking en Byzantijns-robuste dreigingsmitigatie.

Waarom federated learning voor defensie — datasoevereiniteit over commando's heen, de classificatiebarrière en edge-modelversheid

Militaire AI-trainingsdata is bij ontwerp verspreid over organisatiesilo's, niet toevallig. Classificatiebeleid, wettelijke bevoegdheden en operationele veiligheidseisen creëren harde grenzen tussen data-eigenaarorganisaties. ISR-beelden van een Special Operations Command kunnen niet naar de trainingsinfrastructuur van een conventionele krijgsmacht worden gestuurd zonder de compartimentstoegangscontroles te doorlopen die maanden kunnen kosten om op te lossen — als oplossing überhaupt mogelijk is. Een geallieerd partnerland dat sensordata bijdraagt aan een coalitiemodel mag die data onder nationale veiligheidswetgeving niet wettelijk overdragen buiten zijn soevereine infrastructuur, ongeacht de verdragskaders tussen de landen.

De classificatiebarrière is het scherpste probleem. Gecentraliseerd trainen op data met meerdere classificatieniveaus vereist dat de trainingsinfrastructuur naar het hoogste gevoeligheidsniveau van een bijdragende dataset wordt getild. Een trainingscluster dat is geautoriseerd voor Top Secret/SCI-data kost een ordegrootte meer om te bouwen, te bemensen en te accrediteren dan een Secret-niveau-faciliteit, en beperkt de pool van ingenieurs en datawetenschappers die ermee kunnen werken tot een fractie van het personeelsbestand. In de praktijk kiezen de meeste defensie-AI-programma's ervoor te trainen op de minst gevoelige beschikbare data in plaats van een faciliteit op hoger niveau te accrediteren — wat betekent dat het model de meest operationeel relevante trainingsvoorbeelden wordt onthouden. Federated learning elimineert dit compromis door elke silo in staat te stellen op zijn eigen classificatieniveau bij te dragen aan het globale model. De gradiëntupdates die elke silo verlaten dragen geen classificatiemarkering die equivalent is aan de brondata — het zijn wiskundige artefacten van het trainingsproces, geen datarecords.

Edge-modelversheid is de derde motivatie. Een edge AI inference military systems-uitdaging is dat het model dat maanden geleden op een tactisch platform is ingezet, is getraind op een momentopname van de wereld die niet langer met de huidige operationele omgeving overeenkomt. Doelvoertuigsets evolueren, nieuwe radargolfvormen worden ingezet, en camouflage-technieken van de tegenstander passen zich aan om bekende detectiepatronen te omzeilen. Federated learning maakt continue modelverbetering mogelijk vanuit data die op ingezette platforms en vooruitgeschoven operatiebases wordt verzameld, waarbij verbeteringen terugvloeien naar het globale model zonder dat platforms ruwe operationele data omhoog door de keten hoeven te sturen — een bandbreedte- en veiligheidsbeperking die exfiltratie van ruwe data vanuit tactische platforms onpraktisch maakt. Het model verbetert vanuit het veld terwijl de data in het veld blijft.

FL-architecturen voor defensie: cross-silo versus cross-device — federatie op commando- en platformniveau

Federated learning in defensie-implementaties valt uiteen in twee fundamenteel verschillende architectuurpatronen, elk geschikt voor een andere laag van de militaire organisatiehiërarchie. Het verschil begrijpen is een voorwaarde voor het kiezen van het juiste framework, de juiste aggregatiestrategie en de juiste veiligheidsarchitectuur.

Cross-silo-federatie verbindt een klein aantal grote, institutioneel stabiele deelnemers — doorgaans 5–50 — elk met substantiële geclassificeerde datasets. In een defensiecontext zijn cross-silo-deelnemers militaire commando's, inlichtingendiensten, partnerlanden of platformprogrammakantoren. Elke silo heeft een toegewijde rekeninfrastructuur die een volledige modeltrainingsloop kan draaien, een permanente netwerkverbinding met de aggregatieserver (met geplande onderhoudsvensters voor ontkoppeling), en institutioneel gezag over zijn data. Cross-silo-federatie tolereert hogere communicatiekosten per ronde omdat de deelnemers goed gefinancierd zijn, en profiteert van de statistische rijkdom van elke deelnemer grote lokale dataset. De belangrijkste technische uitdigen zijn heterogene dataverdelingen over organisaties, juridische en beleidskaders rond deelname, en de authenticatie- en autorisatie-infrastructuur die nodig is om te garanderen dat alleen geautoriseerde silo's aan het globale model kunnen bijdragen.

Cross-device-federatie verbindt een groot aantal deelnemers met beperkte middelen en episodische beschikbaarheid — potentieel duizenden afzonderlijke soldatentoestellen, sensorknooppunten, UAV-grondstations of voertuigrekenmodules. Elk apparaat heeft slechts een kleine hoeveelheid lokaal gegenereerde data, heeft intermitterende netwerkconnectiviteit en kan onvoorspelbaar in en uit de federatie vallen. Cross-device FL vereist asynchrone aggregatie, agressieve gradiëntcompressie om de communicatiebandbreedte te minimaliseren, en statistische methoden die bruikbaar signaal kunnen halen uit zeer kleine, sterk niet-IID (non-independent-and-identically-distributed) lokale datasets. Het is de passende architectuur voor tactische meshnetwerk-AI, waarbij het doel is een gedeeld model te updaten vanuit de collectieve ervaring van een gedistribueerd sensornetwerk zonder dat een individueel knooppunt ooit genoeg data accumuleert om zelf betekenisvol te trainen.

De meeste institutionele defensie-AI-programma's — die opereren op commando-, domein- of program-of-record-niveau — gebruiken cross-silo-architectuur met 10–30 goed geïdentificeerde deelnemers. Cross-device-architectuur is vooral van toepassing op experimentele tactische AI-programma's waarbij afzonderlijke platforms de trainingsdeelnemers zijn. De twee kunnen hiërarchisch worden gecombineerd: cross-device-federatie op tactisch netwerkniveau aggregeert tot een cross-silo-deelnemer op operationeel commandoniveau, die op zijn beurt deelneemt aan een strategische cross-silo-federatie. Deze hiërarchische structuur maakt het mogelijk dat data van individuele tactische sensoren uiteindelijk het globale model beïnvloeden zonder dat ruwe sensordata meer dan één netwerkhop aflegt.

Differentiële privacy voor militaire trainingsdata — DP-SGD-ruiskalibratie, epsilonselectie voor defensietoepassingen, afweging bruikbaarheid versus privacy

Gradiëntupdates zijn, hoewel geen ruwe data, niet volledig ondoorzichtig. Onderzoek heeft aangetoond dat gradient-inversion-aanvallen individuele trainingsamples met verbazingwekkende getrouwheid kunnen reconstrueren uit gradiëntupdates, met name bij kleine lokale batchgroottes en ondiepe modelarchitecturen. In een defensiecontext kan zelfs gedeeltelijke reconstructie van trainingsdata uit een onderschepte gradiënt inlichtingenbronnen compromitteren, sensorverzamelingspatronen onthullen of platformcapaciteiten prijsgeven. Differentiële privacy (DP) biedt een wiskundig rigorueus mechanisme om deze lekage te begrenzen.

DP-SGD (Differentially Private Stochastic Gradient Descent) past twee bewerkingen toe op elke gradiënt voordat die de trainsilo verlaat. Ten eerste begrenst per-sample-gradiëntclipping de gevoeligheid van het trainingssignaal: de L2-norm van de gradiënt van elk afzonderlijk sample wordt geclipt op een maximale waarde C, zodat één enkel trainingsvoorbeeld de gradiëntupdate niet kan domineren. Ten tweede wordt gekalibreerde Gaussiaanse ruis met een standaardafwijking evenredig aan C / sigma toegevoegd aan de geclipte gradiëntsom. De verhouding C / sigma is de noisemultiplier; grotere sigma-waarden voegen meer ruis toe, wat sterkere privacy biedt ten koste van een meer gedegradeerd gradiëntsignaal.

De formele privacygarantie wordt uitgedrukt als epsilon (het privacybudget) en delta (een verwaarloosbare faalkans). Na R trainingsrondes, elk met een lokale batchgrootte B getrokken uit N totale trainingssamples, groeit de geaccumuleerde epsilon ongeveer als epsilon ≈ (q * sigma_inv * sqrt(2 * R * log(1/delta))) waarbij q = B/N de bemonsteringssnelheid is. In de praktijk gebeurt de tracking met de moments accountant of Renyi Differential Privacy accounting, wat strengere grenzen geeft dan de basiscompositiestelling.

# DP-SGD with Opacus (PyTorch) — defense FL configuration
import torch
from opacus import PrivacyEngine
from opacus.accountants import RDPAccountant

model = MyDetectionModel()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

privacy_engine = PrivacyEngine(accountant="rdp")

model, optimizer, train_loader = privacy_engine.make_private_with_epsilon(
    module=model,
    optimizer=optimizer,
    data_loader=train_loader,
    epochs=local_epochs,
    target_epsilon=3.0,       # authorized privacy budget for SECRET data
    target_delta=1e-5,        # negligible failure probability
    max_grad_norm=1.0,        # clipping norm C (set to median gradient norm)
)

# Train local epochs
for epoch in range(local_epochs):
    for batch in train_loader:
        optimizer.zero_grad()
        loss = criterion(model(batch["inputs"]), batch["labels"])
        loss.backward()
        optimizer.step()  # gradient clipping + noise injection happens here

# Check remaining budget before transmission
epsilon_consumed = privacy_engine.get_epsilon(delta=1e-5)
assert epsilon_consumed <= AUTHORIZED_EPSILON_CEILING, "Privacy budget exceeded"

Epsilonselectie voor defensietoepassingen hangt af van het classificatieniveau van de trainingsdata en het tegenstandermodel. Een bruikbare heuristiek voor defensieprogramma's is epsilon te staffelen op classificatie: ongeclassificeerde trainingsdata kan epsilon 8–12 verdragen, waarbij de nauwkeurigheidsimpact minimaal is; Secret-data rechtvaardigt epsilon 2–5, waarbij er een materiële nauwkeurigheidskosten is maar de wiskundige garantie sterk is; Top Secret- of compartimentsdata kan epsilon nabij 1 vereisen, waarbij de nauwkeurigheidsdegradatie significant is en moet worden afgewogen tegen de privacy-eis. De nauwkeurigheidskosten van sterke DP zijn reëel — een detectiemodel dat met epsilon = 1 is getraind kan 3–6 mAP verliezen ten opzichte van een niet-private baseline — en programmakantoren moeten deze afweging formeel aanvaarden in plaats van die impliciet te laten maken door de softwarekeuzes van een ingenieur.

Modelaggregatiestrategieën — FedAvg, FedProx voor heterogene dataverdelingen, gewogen aggregatie op datakwaliteit en -hoeveelheid

FedAvg (Federated Averaging), het canonieke FL-aggregatiealgoritme, berekent de globale modelupdate als een eenvoudig gemiddelde van de gradiëntupdates van de deelnemers over één ronde. Het is eenvoudig, communicatie-efficiënt en goed begrepen. Het is ook broos wanneer de dataverdelingen van de deelnemers sterk heterogeen zijn — de situatie die in militaire cross-silo-implementaties eerder regel dan uitzondering is, waarbij de trainingsdata van elke organisatiesilo diens specifieke operationele context, sensorplatform en geografisch inzetgebied weerspiegelt.

Het heterogeniteitsprobleem manifesteert zich als client drift: het lokaal geoptimaliseerde model van elke deelnemer drijft in een richting die door diens lokale dataverdeling wordt bepaald, en het gemiddelde van meerdere gedreven modellen kan slechter zijn dan het lokale model van een afzonderlijke deelnemer. Een commando dat uitsluitend in een arctisch inzetgebied opereert, traint zijn lokale model om sneeuwbedekte voertuigen te herkennen; een commando in een woestijntheater specialiseert zich in zandkleurige doelsignaturen. Het middelen van de twee levert een model dat slechter presteert dan beide. FedProx pakt client drift aan door een proximale regularisatieterm toe te voegen aan de lokale doelfunctie van elke deelnemer:

# FedProx local objective — adds proximal term to standard loss
# w_global = global model weights from last aggregation round
# w_local  = local model weights being updated
# mu       = proximal regularization strength (0.01 – 0.1)

def fedprox_loss(predictions, targets, w_local, w_global, mu=0.05):
    task_loss = criterion(predictions, targets)
    proximal_term = (mu / 2) * sum(
        torch.norm(w_l - w_g) ** 2
        for w_l, w_g in zip(w_local.parameters(), w_global.parameters())
    )
    return task_loss + proximal_term

De proximale term bestraft lokale modeldrift weg van het globale startpunt, waardoor geen enkele deelnemer de aggregaatupdate te ver in de richting van zijn lokale dataverdeling kan trekken. De mu-hyperparameter stuurt de afweging: mu = 0 herstelt standaard FedAvg (geen regularisatie); mu = 1.0 voorkomt dat lokale optimalisatie het globale model verbetert (te veel regularisatie). Waarden in het bereik 0.01–0.1 zijn typisch voor defensie-cross-silo-implementaties. Het afstemmen van mu vereist het monitoren van de nauwkeurigheid van het globale model op een achtergehouden centrale evaluatiedataset over de trainingsrondes heen — als de nauwkeurigheid oscilleert of niet convergeert, verhoog dan mu; als de convergentie te traag is, verlaag die dan.

Gewogen aggregatie op datahoeveelheid vervangt gelijk-gewichtige middeling door sample-count-proportionele aggregatie. Een commando met 500.000 gelabelde voorbeelden moet meer bijdragen aan de globale update dan een vooruitgeschoven operatiebasis met 800 voorbeelden. Sample-count-weighting is rechttoe rechtaan: elke deelnemer meldt zijn lokale sample count (deze count-metadata maakt de data-inhoud niet zichtbaar), en de server berekent het gewicht van elke deelnemer als diens count gedeeld door het totaal over alle deelnemende silo's in de ronde.

Gewogen aggregatie op datakwaliteit is complexer. Kwaliteitsproxy's die zonder toegang tot ruwe data berekenbaar zijn, omvatten lokale modelvalidatienauwkeurigheid (als een achtergehouden lokale validatieset beschikbaar is), gradiëntnorm (zeer grote of kleine gradiëntnormen kunnen op datakwaliteitsproblemen duiden) en modelovereenstemming (of de lokale update in een vergelijkbare richting wijst als de aggregaat van de overige deelnemers). Defensieprogramma's met heterogene sensorkwaliteit — een mix van hoge-resolutie elektro-optische beelden van strategische ISR-middelen en laag-resolutie camera's op grondvoertuigen — dienen kwaliteitsgewogen aggregatie te implementeren, zodat databronnen van lage kwaliteit de prestaties van het globale model niet degraderen op de detectietaken met hoge inzet die van de hogere kwaliteit data afhankelijk zijn.

Secure-aggregation-protocollen — cryptografische aggregatie (SecAgg), trusted execution environment voor de aggregatieserver, gradiëntencryptie

De aggregatieserver is het enige punt in de FL-architectuur dat gradiëntupdates van alle deelnemers moet verwerken. Ook al hebben afzonderlijke deelnemers geen toegang tot elkaars gradiënten, de exploitant van de aggregatieserver — en elke tegenstander die de server compromitteert — kan alle individuele gradiëntuploads waarnemen. In een defensie-FL-implementatie waarbij de deelnemers verschillende organisaties of landen zijn, creëert deze gecentraliseerde zichtbaarheid een inlichtingenverzamelingsrisico: een geraffineerde tegenstander die de aggregatieserver controleert of is binnengedrongen, kan gradient-reconstructieaanvallen uitvoeren tegen de trainingsdata van afzonderlijke deelnemers.

Secure aggregation (SecAgg) elimineert deze blootstelling doordat de server de aggregaat van de gradiënten van de deelnemers kan berekenen zonder ooit de gradiënt van een afzonderlijke deelnemer in leesbare vorm te zien. Het protocol gebruikt paargewijze secret sharing tussen deelnemers:

• In de setup-fase stelt elk paar deelnemers via een geauthenticeerd kanaal een gedeelde secret in met Diffie-Hellman-sleuteluitwisseling. De aggregatieserver faciliteert de sleutelverdeling maar leert de paargewijze secrets niet.
• Voor het uploaden van zijn gradiënt genereert elke deelnemer voor elk van zijn partners een pseudowillekeurige maskersvector (afgeleid van de paargewijze secret), en telt al deze maskers op bij zijn gradiënt. Het masker voor het deelnemerspaar (i, j) wordt met positief teken toegevoegd door deelnemer i en met negatief teken door deelnemer j.
• Wanneer alle gemaskeerde gradiënten op de server worden opgeteld, vallen de maskers paargewijze weg, zodat alleen de echte som van ongemaskeerde gradiënten overblijft. De server heeft de aggregaat correct berekend zonder ooit de leesbare gradiënt van een afzonderlijke deelnemer te zien.
• Uitval van deelnemers wordt afgehandeld met een secret-sharing-schema voor de maskersleutels: als een deelnemer uitvalt vóór het indienen, kan een threshold van andere deelnemers het masker van die deelnemer reconstrueren en uit de aggregaat verwijderen.

Het trusted execution environment (TEE) van de aggregatieserver biedt een aanvullende beschermingslaag. Een TEE — geïmplementeerd via Intel TDX, AMD SEV-SNP of ARM TrustZone — creëert een hardware-geïsoleerde uitvoeringscontext waarin code en data zelfs tegen het besturingssysteem en de hypervisor van de infrastructuur zijn versleuteld en beschermd. Wanneer de aggregatieserver binnen een TEE draait, kan de serverexploitant de geaggregeerde gradiënt niet in leesbare vorm inspecteren zonder de attestatiegaranties van de TEE te breken. Remote attestation stelt deelnemers in staat cryptografisch te verifiëren dat de aggregatieserver de geautoriseerde aggregatiecode in een authentieke TEE draait voordat ze gradiëntupdates indienen. Dit adresseert de insiderdreiging op het niveau van de infrastructuurexploitant — een cloudbeheerder of een overheids-IT-contractor die de infrastructuur van de aggregatieserver beheert, kan beheerderstoegang niet gebruiken om gradiëntverkeer te onderscheppen.

Voor computer vision defense systems die deelnemen aan een cross-silo-FL-programma moet het volledige datapad — van lokale trainingsoutput, via masking, over een versleuteld transport, via TEE-gebaseerde aggregatie, en terug naar de deelnemer als bijgewerkt globaal model — worden gedocumenteerd en geaccrediteerd als onderdeel van het security authorization package van het programma. Elke schakel in de keten vereist een eigen beoordeling van de veiligheidsbeheersingen.

FL in niet-verbonden en intermitterende tactische omgevingen — asynchrone FL met vertraagde gradiënten, satellietlinkscheduling, modelversioning voor verouderde gradiënten

Het ideale FL-protocol veronderstelt dat alle deelnemers tegelijk bereikbaar zijn aan het begin van elke trainingsronde en bereikbaar blijven gedurende de ronde. Tactische militaire omgevingen schenden deze aanname systematisch. Uitkijkposten via satelliet hebben misschien slechts connectiviteitsvensters van 20 minuten elke 12 uur. Te voet opererende eenheden in terrein zonder communicatie kunnen dagen offline zijn. Deelnemers op voertuigen kunnen intermitterende connectiviteit hebben door terreinmaskering, radiofrequente interferentie van tegenstanderjamming, of emissiecontroleprocedures (EMCON) die uitzenden verbieden.

Asynchrone federated learning ontkoppelt de beschikbaarheid van deelnemers van de aggregatietiming. In plaats van alle gradiënten van de deelnemers te verzamelen voordat een ronde wordt berekend, houdt de aggregatieserver een gradiëntbuffer bij en past updates toe naarmate ze binnenkomen. Het globale model gaat continu vooruit en neemt de bijdrage van elke deelnemer op het moment van aankomst op. De technische uitdaging is gradient staleness: een deelnemer die zijn lokale model heeft getraind op globale modelversie T en zijn gradiënt indient op tijd T+5 draagt een gradiënt bij die is berekend ten opzichte van een model dat inmiddels vijf globale stappen verouderd is. Het naïef aggregeren van verouderde gradiënten kan de convergentie vertragen of, in extreme gevallen, destabiliseren.

# Staleness-weighted asynchronous aggregation (server side)
# Each gradient submission includes the round number it was computed from

def async_aggregate(gradient_buffer, current_round, max_staleness=10):
    """
    Aggregate gradient updates from the buffer, applying staleness weighting.
    Discard updates older than max_staleness rounds.
    """
    valid_updates = [
        (g, w, r) for g, w, r in gradient_buffer
        if (current_round - r) <= max_staleness
    ]

    total_weighted_grad = None
    total_weight = 0.0

    for grad, sample_weight, submission_round in valid_updates:
        staleness = current_round - submission_round
        # Exponential staleness decay: weight halves every 3 rounds
        staleness_factor = 0.5 ** (staleness / 3.0)
        effective_weight = sample_weight * staleness_factor

        scaled_grad = {k: v * effective_weight for k, v in grad.items()}
        if total_weighted_grad is None:
            total_weighted_grad = scaled_grad
        else:
            for k in total_weighted_grad:
                total_weighted_grad[k] += scaled_grad[k]
        total_weight += effective_weight

    # Normalize by total weight
    return {k: v / total_weight for k, v in total_weighted_grad.items()}

Satellietlink-FL-scheduling stemt het afronden van trainingsrondes af op voorspelde connectiviteitsvensters. Als de satellietlink van een deelnemer dagelijks beschikbaar is van 02:00–02:20 UTC, moet de trainingsclient van die deelnemer zo worden geconfigureerd dat de lokale training is afgerond en de gradiënt klaarstaat voor verzending vóór 02:00. De server plant aggregatierondes met een deadline die overeenkomt met het connectiviteitsvenster van de laatste deelnemer. Voor deelnemers met meerdere passages per dag kan de trainingsclient de meest recente gradiënt gebruiken als sinds de laatste verzending een trainingsrun is afgerond, waarmee de complexiteit van gradiëntaccumulatie over passages heen wordt vermeden.

Modelversioning op deelnemerniveau is essentieel voor weerbaarheid. De lokale modelopslag dient minstens drie checkpoints te bewaren: het huidige ingezette inferentiemodel, het laatst ontvangen globale model (gebruikt als startpunt voor lokale training), en het in bewerking getrainde lokale model (vóór gradiëntextractie). Als de connectiviteit na een lokale trainingsrun verloren gaat maar vóór de gradiëntverzending, kan de gradiënt worden bewaard en in het volgende connectiviteitsvenster worden verzonden zonder de trainingsberekening te herhalen. Als de deelnemer tijdens een lopende lokale trainingsrun een globale modelupdate ontvangt, moet die beslissen of de huidige run wordt afgerond (en een mogelijk verouderde gradiënt wordt ingediend) of dat er opnieuw wordt gestart vanaf het nieuwe globale model (waarbij de rekeninvestering verloren gaat). Voor power-constrained edge inference-platforms waar rekenkracht duur is, is het afronden van de huidige run en het accepteren van veroudering meestal het betere beleid.

Dreigingsmodel voor federated militaire AI — Byzantijns-robuste aggregatie (Krum, Trimmed Mean), modelpoisoningdetectie, mitigatie van gradient-inversion-aanvallen

Federated learning in defensieprogramma's opereert tegen een geraffineerder dreigingsmodel dan civiele FL-toepassingen. De tegenstander heeft zowel de motivatie als potentieel de technische capaciteit om FL-deelnemers te compromitteren, gradiëntverzendingen te onderscheppen, of de aggregatie-infrastructuur binnen te dringen. De dreigingscategorieën die relevant zijn voor militaire FL zijn gradiëntpoisoning (een gecompromitteerde deelnemer dient kwaadaardige gradiënten in), modelpoisoning (de tegenstander injecteert trainingsdata die een backdoored model moet opleveren), gradient inversion (een afluisteraar reconstrueert trainingsdata uit onderschepte gradiëntupdates), en compromittering van de aggregatieserver (de tegenstander krijgt toegang tot het centrale aggregatiepunt).

Byzantijns-robuste aggregatie verdedigt tegen gradiëntpoisoning door de globale update ongevoelig te maken voor een begrensd aantal adversarial-deelnemersbijdragen. Standaard FedAvg is niet Byzantijns-robuust — één enkele deelnemer die een gradiënt indient in de tegenovergestelde richting van de echte gradiënt kan de convergentie merkbaar degraderen. Byzantijns-robuuste algoritmen selecteren ofwel een subset gradiënten, of berekenen een robuuste statistiek die adversarial-invloed begrenst:

Multi-Krum selecteert de m gradiënten die het meest lijken op hun k naaste buren onder alle ingediende gradiënten. Byzantijnse gradiënten, die zijn ontworpen om de globale update te beïnvloeden, zijn vaak uitschieters in de gradiëntverdeling — ver verwijderd van de cluster eerlijke gradiënten. Het selectiecriterium van Krum verwerpt deze uitschieters. Het algoritme vereist een bovengrens f voor het aantal Byzantijnse deelnemers; stel voor de veiligheid de Krum-parameter in op n - f - 2, waarbij n het totale aantal deelnemers is.

Coordinate-wise Trimmed Mean verwerpt in elke dimensie onafhankelijk het bovenste en onderste p-aandeel van de gradiëntwaarden voordat het gemiddelde wordt berekend. Dit is rekenkundig goedkoper dan Krum en effectief wanneer Byzantijnse gradiënten extreem zijn in afzonderlijke dimensies — een veelvoorkomende structuur bij eenvoudige gradiëntaanvalstrategieën. Het trimfractie p dient te worden ingesteld op minstens het veronderstelde Byzantijnse aandeel plus een veiligheidsmarge van 5–10%.

# Coordinate-wise Trimmed Mean aggregation
import numpy as np

def trimmed_mean_aggregate(gradients, trim_fraction=0.2):
    """
    Byzantine-robust aggregation: trim top and bottom trim_fraction
    of gradient values per dimension, then average.

    gradients: list of flat numpy arrays, one per participant
    trim_fraction: fraction to trim from each tail (e.g., 0.2 = 20%)
    """
    grad_matrix = np.stack(gradients, axis=0)  # shape: (n_participants, n_params)
    n = grad_matrix.shape[0]
    k = int(np.floor(trim_fraction * n))        # number to remove from each tail

    # Sort along participant axis, trim k from top and bottom
    sorted_grads = np.sort(grad_matrix, axis=0)
    trimmed = sorted_grads[k : n - k, :]       # remove k from each end

    return np.mean(trimmed, axis=0)

Modelpoisoningdetectie vereist het monitoren van het gedrag van het globale model op een schone centrale evaluatiedataset na elke aggregatieronde. Een plotselinge daling van de nauwkeurigheid, een stijging van de false-negativerate voor een specifieke doelklasse, of het ontstaan van onverwacht classificatiegedrag (zoals classificatie met hoge betrouwbaarheid maar fout resultaat van een specifiek voertuigtype dat vóór de ronde niet in de evaluatieset voorkwam) zijn indicatoren van geslaagde poisoning. Defensie-FL-programma's dienen een holdout-evaluatieset bij te houden die is samengesteld door een team dat onafhankelijk is van elke FL-deelnemer, zodat geen enkele deelnemer kan trainen om goed te presteren op de evaluatieset terwijl hij het operationele gedrag van het model vergiftigt. Anomaliedetectie op gradiëntstatistieken per deelnemer — gradiëntnorm, cosinusoorteenkomst met de aggregaat van de ronde, en variantie over de trainingsrondes — levert een vroegtijdig waarschuwingssignaal dat het gradiëntgedrag van een deelnemer is veranderd, wat op compromittering kan duiden.

Mitigatie van gradient inversion verloopt via drie elkaar aanvullende mechanismen. Ten eerste verdoezelt DP-SGD-ruis gradiëntwaarden onder de ruisdrempel, wat reconstructie met hoge getrouwheid voorkomt. Ten tweede zorgt SecAgg ervoor dat alleen aggregaatgradiënten zichtbaar zijn op de aggregatieserver, waardoor het aanvalsoppervlak beperkt blijft tot het communicatiekanaal tussen elke deelnemer en de server. Ten derde vergroot het verhogen van de lokale batchgrootte van enkele cijfers naar 64 of meer samples per gradiëntstap de moeilijkheid van reconstructie drastisch, omdat de gradiënt een gemiddelde is over veel samples in plaats van een vingerafdruk van één enkel record. Voor de meest gevoelige trainingsdata voorkomen lokale batchgroottes van 128 of hoger effectief dat huidige gradient-inversion-technieken individuele trainingsrecords terugwinnen.