🤖 AI

Shard the Gradient, Scale the Model: Serverless Federated Aggregation via Gradient Partitioning

Het voorgestelde GradsSharding-raamwerk maakt het mogelijk om federated learning op serverless platforms te schalen naar zeer grote modellen door de gradiënten op te delen in kleinere fragmenten, waardoor de geheugenlimieten van individuele functies worden omzeild.

Oorspronkelijke auteurs: Amine Barrak

Gepubliceerd 2026-04-27

📖 4 min leestijd☕ Koffiepauze-leesvoer

CC0 1.0

Oorspronkelijke auteurs: Amine Barrak

Oorspronkelijk artikel vrijgegeven aan het publieke domein onder CC0 1.0 (http://creativecommons.org/publicdomain/zero/1.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je een gigantische puzzel van 10.000 stukjes moet maken, maar je hebt een probleem: de tafel waar je aan werkt is veel te klein. Je kunt de hele puzzel niet eens uitspreiden zonder dat de helft op de grond valt.

Dit is precies het probleem waar computerwetenschappers tegenaan lopen bij Federated Learning (Federated Leren).

Hier is de uitleg van het onderzoek naar GRADSSHARDING, in begrijpelijke taal.

Het Probleem: De "Te Kleine Tafel"

Stel je voor dat duizenden mensen (de 'clients') over de hele wereld een klein stukje van een enorme digitale puzzel (een AI-model) aan het leggen zijn. Als ze klaar zijn, moeten al die stukjes naar één centrale plek worden gestuurd om samen te voegen tot het complete plaatje.

In de computerwereld gebruiken we hiervoor vaak 'Serverless' technieken (zoals AWS Lambda). Dit is een soort "huur-tafel": je huurt een tafel voor precies de tijd dat je de puzzelstukjes moet samenvoegen, en zodra je klaar bent, betaal je niets meer. Dat is super goedkoop!

Maar er is een addertje onder het gras: die huur-tafels zijn erg klein. Ze hebben een strikte limiet aan hoeveel "puzzelstukjes" (geheugen) ze tegelijk kunnen vasthouden. Als het AI-model (de puzzel) te groot wordt, past het simpelweg niet meer op de tafel. De computer zegt dan: "Sorry, dit is te groot, ik kan het niet verwerken." De huidige methodes proberen de puzzel op te lossen door meer tafels te huren en de stukjes in groepjes te verdelen, maar elke tafel moet nog steeds het volledige plaatje kunnen begrijpen. Dat werkt niet bij de echt grote modellen.

De Oplossing: De "Puzzel-Slicer" (GRADSSHARDING)

De onderzoekers van dit paper hebben een slimme truc bedacht: GRADSSHARDING.

In plaats van te proberen de hele puzzel op één tafel te leggen, zeggen zij: "Laten we de puzzel in smalle stroken snijden."

Stel je voor dat je een enorme foto hebt. In plaats van dat één persoon de hele foto moet bekijken, snijd je de foto in 10 verticale stroken.

Persoon 1 krijgt alleen de linkerstrook.
Persoon 2 krijgt de tweede strook, enzovoort.

Elke persoon heeft een heel kleine tafel nodig, want ze hoeven maar één strook tegelijk te bekijken. Ze hoeven de rest van de foto niet eens te zien! Als ze klaar zijn met hun strook, plakken we ze simpelweg weer aan elkaar tot de complete foto.

Het mooie hiervan?

Geen limiet: Als de puzzel nóg groter wordt, snijden we de stroken gewoon nóg dunner. Je kunt in theorie een puzzel van de grootte van een voetbalstadion verwerken, zolang je maar genoeg dunne stroken hebt.
Snelheid: Omdat iedereen tegelijkertijd aan zijn eigen strook werkt, ben je veel sneller klaar. Het is alsover een hele groep mensen die tegelijkertijd een strookje lijmt, in plaats van één persoon die alles achter elkaar doet.
Betrouwbaarheid: De resultaten zijn exact hetzelfde als wanneer je de hele puzzel in één keer zou doen. Er gaat geen stukje verloren.

Wat hebben ze bewezen?

De onderzoekers hebben dit getest met echte, zware AI-modellen (zoals die gebruikt worden voor taal en beeldherkenning). Hun conclusies waren:

De "Grote Modellen" muur: De oude methodes liepen vast zodra de modellen groter werden dan een paar gigabyte. GRADSSHARDING bleef gewoon doorgaan.
Besparing: Voor middelgrote modellen is deze methode bijna 3 keer goedkoper dan de oude manier.
Snelheid: Het is veel sneller omdat je de taken perfect kunt verdelen over heel veel kleine "werkers".

Samenvatting in één zin

In plaats van te proberen een gigantische berg informatie in één keer door een kleine trechter te duwen (wat de trechter verstopt), snijdt GRADSSHARDING de informatie in kleine snippers die allemaal tegelijkertijd door duizenden kleine trechters kunnen stromen.

Technische Samenvatting: Shard the Gradient, Scale the Model

Het Probleem: De "Memory Ceiling" in Serverless Federated Learning

Federated Learning (FL) stelt apparaten in staat om gezamenlijk machine learning-modellen te trainen zonder ruwe data te delen. Een cruciaal onderdeel is de aggregatie-stap, waarbij een centrale server de gradiënten (updates) van alle clients middelt.

Hoewel serverless platforms (zoals AWS Lambda) ideaal zijn voor FL vanwege hun schaalbaarheid en "pay-per-use" model, stuiten bestaande architecturen ( $\lambda$ -FL en LIFL) op een fundamentele limiet: de geheugenrestrictie. Bestaande systemen verdelen de taken op basis van het aantal clients (bijv. via een boomstructuur), maar elke aggregator moet nog steeds de volledige gradiënt-tensor in het geheugen laden. Wanneer moderne modellen (zoals GPT-2 of grote vision-modellen) groter worden dan de geheugenlimiet van een serverless functie (bijv. 10 GB op AWS Lambda), wordt aggregatie onmogelijk, ongeacht de diepte van de boomstructuur.

Methodologie: GRADSSHARDING

De auteurs stellen GRADSSHARDING voor, een architectuur die de aggregatie niet verdeelt over clients, maar over de dimensies van de gradiënt zelf.

Gradient Sharding: In plaats van de volledige gradiënt te verwerken, wordt de gradiënt-tensor opgedeeld in $M$ gelijke delen (shards) langs de parameter-as.
Parallelle Aggregatie: Voor elke shard wordt een onafhankelijke serverless functie getriggerd. Deze functie verzamelt alleen de bijbehorende shard van alle clients, berekent het gemiddelde en schrijft dit terug naar object storage (S3).
Geheugenbeperking: Omdat elke functie slechts een fractie van de gradiënt verwerkt, is het geheugengebruik per functie begrensd op $O(|\theta|/M)$ . Door $M$ te vergroten, kan men theoretisch modellen van willekeurige grootte aggregeren.
Wiskundige Equivalentie: Omdat het FedAvg-algoritme elementgewijze middeling gebruikt, is het resultaat van het afzonderlijk middelen van shards wiskundig identiek aan het middelen van de volledige tensor. De modelnauwkeurigheid blijft dus ongewijzigd.

Belangrijkste Bijdragen

Nieuwe Architectuur: De eerste serverless FL-architectuur die het geheugengebruik per functie loskoppelt van zowel de modelgrootte als het aantal clients.
Empirische Validatie: Een uitgebreide vergelijking met de huidige state-of-the-art ( $\lambda$ -FL en LIFL) op echte AWS Lambda-infrastructuur.
Schaalbaarheidsanalyse: Het identificeren van de exacte grenzen waar traditionele methoden falen en hoe GRADSSHARDING deze overstijgt.

Resultaten

De resultaten uit de experimenten (variërend van 43 MB tot 5 GB aan gradiënten) laten het volgende zien:

Efficiëntie en Kosten:
- Bij kleine modellen (< 500 MB) is $\lambda$ -FL iets goedkoper vanwege lagere S3-overhead.
- Bij middelgrote modellen (zoals VGG-16) is GRADSSHARDING 2,7× goedkoper en 1,7× sneller dan $\lambda$ -FL. Dit komt doordat de besparing op Lambda-geheugen en executietijd groter is dan de extra kosten voor S3-operaties.
Snelheid: Door gebruik te maken van de parallelle aard van serverless functies, biedt GRADSSHARDING een bijna lineaire versnelling in latency naarmate het aantal shards ( $M$ ) toeneemt (tot 16,2× versnelling bij $M=16$ ).
De "Hard Limit": Voor modellen groter dan ongeveer 3 GB (zoals GPT-2 Large) zijn $\lambda$ -FL en LIFL niet meer inzetbaar op AWS Lambda omdat ze de 10 GB geheugenlimiet overschrijden. GRADSSHARDING is de enige architectuur die blijft werken door simpelweg het aantal shards te verhogen.
Bottleneck: De studie toont aan dat de primaire bottleneck niet de rekenkracht (CPU) is, maar de S3 I/O-doorvoer, die 91% tot 99% van de totale aggregatietijd in beslag neemt.

Significantie

Dit onderzoek is van groot belang voor de toekomst van gedistribueerde AI. Het bewijst dat serverless computing niet beperkt is tot kleine machine learning-modellen, maar ook kan worden ingezet voor de enorme modellen van de huidige generatie (Large Language Models), mits de aggregatie-strategie wordt aangepast van "client-gebaseerd" naar "parameter-gebaseerd". Het biedt een praktisch kader voor ontwikkelaars om de optimale balans te vinden tussen kosten, snelheid en modelgrootte in cloud-native federated learning omgevingen.