💻 computer science

ShardTensor: Domain Parallelism for Scientific Machine Learning

Dit artikel introduceert ShardTensor, een nieuw domeinparallelisme-framework dat de ruimtelijke dimensionaliteit van invoergegevens ontkoppelt van hardwarebeperkingen om schaalbare, hoogtrouw trainings- en inferentieprocessen voor wetenschappelijke machinelearning-modellen op datasets met extreme resolutie mogelijk te maken.

Oorspronkelijke auteurs: Corey Adams, Peter Harrington, Akshay Subramaniam, Mohammad Shoaib Abbas, Jaideep Pathak, Mike Pritchard, Sanjay Choudhry

Gepubliceerd 2026-05-13

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Corey Adams, Peter Harrington, Akshay Subramaniam, Mohammad Shoaib Abbas, Jaideep Pathak, Mike Pritchard, Sanjay Choudhry

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.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

Het Grote Probleem: De "Te Groot om te Pasten" Doos

Stel je voor dat je een wetenschapper bent die probeert een orkaan, een zwart gat of een menselijk brein te simuleren. Om nauwkeurige resultaten te krijgen, moet je deze dingen in extreme detail bekijken – alsof je inzoomt op een foto tot je elk afzonderlijk pixel kunt zien.

In de wereld van Kunstmatige Intelligentie (AI) noemt men dit hoogresolutie data.

Het probleem is dat AI-modellen draaien op speciale computers genaamd GPU's (Graphics Processing Units). Deze GPU's hebben een beperkte hoeveelheid geheugen, net als een kleine rugzak.

Het Probleem: Wanneer wetenschappers proberen een enorme, hoogresolutie afbeelding (zoals een 3D-scan van een storm) in de AI te laden, is de data zo groot dat deze simpelweg niet in de rugzak past.
De Oude Oplossing: Wetenschappers moesten de data vroeger "downsamplen". Dit is alsof je een 4K-film verkleint tot een klein, wazig 144p-voorbeeldje, alleen maar zodat het in de rugzak past. De AI kan draaien, maar de resultaten zijn wazig en onnauwkeurig.
De Andere Oude Oplossing: Ze konden proberen de data over meerdere computers te splitsen (Data Parallelism), maar dit werkt alleen als je veel aparte "stukken" data hebt (zoals 100 verschillende stormen). Als je slechts één enorme storm hebt om te analyseren, lopen de oude methoden vast. Je kunt één storm niet zomaar in 100 stukken splitsen zonder de wiskunde te breken.

De Oplossing: ShardTensor (De "Team-Rugzak" Strategie)

De auteurs van NVIDIA introduceerden een nieuw hulpmiddel genaamd ShardTensor.

Stel je ShardTensor voor als een magische manier om één enkele, gigantische pizza (je hoogresolutie data) in plakken te snijden en die plakken te geven aan een team van koks (GPU's) die in een kring staan.

Hoe het werkt: In plaats van te proberen de hele pizza op één bord te passen, snijdt het systeem de pizza ruimtelijk op (naar oppervlak, niet naar aparte pizza's).
- Kok A houdt het linkerbovenste stukje.
- Kok B houdt het rechterbovenste stukje.
- Kok C houdt het linkerbeneden stukje.
De Magie: Wanneer de koks ingrediënten moeten mengen (wiskunde doen), kunnen ze de randen van hun stukken doorgeven aan hun buren. Als Kok A moet weten wat er aan de uiterste rand van zijn stukje gebeurt, vraagt hij het aan Kok B. Ze werken samen om de hele puzzel op te lossen zonder ooit de hele pizza op één bord te hoeven leggen.

Dit noemt men Domain Parallelism. Het stelt wetenschappers in staat om data te verwerken die groter is dan het geheugen van één enkele computer, zelfs als ze slechts één enkele dataset hebben om mee te werken.

Waarom Dit Belangrijk Is (Het "Waarom Moeite Doen?" Deel)

Het paper legt uit dat in wetenschappelijke AI de grootste geheugenverslinder niet het "brein" van de AI is (de modelgewichten); het zijn de tussenstappen (activaties).

Analogie: Stel je voor dat je een gigantisch wiskundig probleem oplost op een whiteboard. Je hebt niet alleen ruimte nodig voor het eindantwoord; je hebt ruimte nodig voor elke losse schetsberekening die je onderweg maakt.
Het Resultaat: Bij hoogresolutie data vullen deze "schetsberekeningen" het geheugen direct op. ShardTensor spreidt deze schetsberekeningen over meerdere GPU's.
Het Voordeel:
1. Strong Scaling: Als je een enorme dataset hebt, zorgt het toevoegen van meer GPU's ervoor dat de taak veel sneller wordt afgerond (alsof je meer arbeiders toevoegt aan een bouwplaats).
2. Weak Scaling: Als je een dataset hebt die zo groot is dat deze eerder onmogelijk te draaien was, kun je deze nu draaien door meer GPU's toe te voegen om de last te delen.

Wereldwijde Voorbeelden uit het Paper

De auteurs testten dit op twee specifieke wetenschappelijke problemen om te bewijzen dat het werkt:

StormScope (Weersvoorspelling):
- De Uitdaging: Het voorspellen van individuele onweersbuien vereist het bekijken van een kaart van de hele Verenigde Staten met zeer hoge detail (3km resolutie).
- Het Probleem: Het geheugen van één enkele computer (80GB) kon de data voor de hele VS-kaart op dat detail niet bevatten. Het was alsof je probeerde de hele VS-kaart in één enkele map te dragen.
- De Oplossing: Met ShardTensor splitsten ze de VS-kaart over 32 GPU's. De AI kon nu het hele land in hoge definitie "zien" en onweersbuien nauwkeurig voorspellen zonder te crashen.
Transolver (Aerodynamica):
- De Uitdaging: Het simuleren van luchtstroom over een auto om het brandstofverbruik te verbeteren.
- Het Resultaat: Ze konden de AI trainen op een mesh (een 3D-rooster) met meer dan 1,2 miljoen punten die de vorm van de auto vertegenwoordigden. Dit niveau van detail was eerder onmogelijk om op één enkele machine te trainen.

Wat het Paper Niet Zegt (Beperkingen)

De auteurs zijn eerlijk over de afwegingen:

Communicatie-Overhead: Omdat de GPU's constant met elkaar moeten praten om de randen van hun data-plakken te delen, gaat er een klein beetje "praattijd" verloren.
Kleine Data: Als de data klein is, maakt deze praattijd het systeem trager dan het gebruik van één enkele computer. ShardTensor is alleen voor enorme data.
Niet Magisch voor Alles: Het werkt het beste met specifieke soorten wiskundige bewerkingen. Sommige oudere of zeer specifieke bewerkingen worden misschien nog niet ondersteund.

Samenvatting

ShardTensor is een nieuw softwarehulpmiddel dat wetenschappers in staat stelt om enorme, hoogresolutie wetenschappelijke data in stukken te snijden en over meerdere computers te verspreiden. Dit stelt hen in staat om AI-modellen te trainen op data die zo gedetailleerd is dat deze eerder niet in het geheugen van één enkele computer paste, wat leidt tot nauwkeurigere weersvoorspellingen, betere auto-ontwerpen en diepere wetenschappelijke ontdekkingen.

Technische Samenvatting: ShardTensor – Domeinparallelisme voor Wetenschappelijk Machine Learning

1. Probleemstelling

Wetenschappelijk Machine Learning (SciML) staat voor een kritieke knelpunt: het onvermogen om te trainen en inferentie uit te voeren op wetenschappelijke data met hoge resolutie vanwege beperkingen in het GPU-geheugen. In tegenstelling tot Large Language Models (LLM's), waar het geheugen vaak wordt gedomineerd door het aantal parameters, worden SciML-werklasten frequent beperkt door intermediaire activaties.

Het artikel identificeert een "rekenkundige vloek van de dimensionaliteit" in wetenschappelijke data. Waar het verdubbelen van de tekstlengte in een LLM de invoertokens ongeveer verdubbelt, verhoogt het verdubbelen van de resolutie van $N$ -dimensionale wetenschappelijke data de datagrootte met $2^N$ . Voor 3D- of hogerdimensionale data (bijvoorbeeld stromingsdynamica, medische beeldvorming, klimaatmodellering) groeit het geheugen dat nodig is om intermediaire activaties op te slaan tijdens de terugwaartse doorloop van het trainen exponentieel.

Bestaande oplossingen schalen vaak niet of degraderen de nauwkeurigheid:

Verminderde precisie: Biedt slechts bescheiden (2x) geheugenvoordeel en kan lijden onder problemen met dynamisch bereik in wetenschappelijke surrogaten.
Ruimtelijke downsampling: Vermindert het geheugengebruik maar offert de hoge-resolutie resolutie op die vereist is voor wetenschappelijke doorbraken.
Modelreductie: Vermindert de nauwkeurigheid.
Activatie-checkpointing/CPU-offloading: Effectief maar introduceert aanzienlijke rekenkundige overhead (herberekening of host-device-overdrachten).
Standaard parallelisme: Data-parallelisme (het splitsen van de batch) stuit op een harde limiet bij een batchgrootte van 1. Modelparallelisme (het splitsen van gewichten) is ontworpen voor parameters, niet voor invoerdata, en veronderstelt statische tensorvormen die niet gelden voor dynamische invoerdata-verwerking (bijvoorbeeld convoluties die globale vormen veranderen).

Gevolg hiervan is dat er geen algemeen kader bestaat voor het paralleliseren van invoerdata onder een batchgrootte van één per apparaat, wat SciML verhindert om de native resoluties te bereiken die wetenschappers vereisen.

2. Methodologie: ShardTensor

De auteurs introduceren ShardTensor, een nieuw paradigma van domeinparallelisme dat de ruimtelijke dimensionaliteit van invoerdata ontkoppelt van hardwarebeperkingen. Het is een extensie van PyTorch's DTensor (Distributed Tensor) abstractie, specifiek ontworpen om invoerdata te verwerken in plaats van modelgewichten.

Kernontwerpprincipes

Domeinparallelisme: Gedefinieerd als parallelisme over apparaten voor invoerdata, verdergaand dan de batchdimensie. Wanneer de batchgrootte 1 bereikt, subdivideert ShardTensor de ruimtelijke dimensies (bijvoorbeeld hoogte, breedte, diepte) over meerdere GPU's.
Dynamische vormverwerking: In tegenstelling tot DTensor, dat statische distributievormen veronderstelt die geschikt zijn voor modelgewichten, ondersteunt ShardTensor dynamische vormen. Het introduceert een vierde component van metadata: sharding-vormen, die de lokale chunkvorm van elke tensor langs de gesplitste mesh-as beschrijven. Dit maakt willekeurige chunking van ongestructureerde of niet-uniforme data mogelijk.
Imperatieve dispatch: Het kader is imperatief in plaats van statisch. Het maakt gebruik van PyTorch's __torch_dispatch__ en __torch_function__ mechanismen om bewerkingen dynamisch te routeren. Dit stelt het systeem in staat om laag-voor-laag domeinparallelisme te hanteren zonder vooraf gecompileerde rekenkundige grafieken of specifieke patches voor elke laag te vereisen.
Uitbreidbaarheid: Gebruikers kunnen het systeem uitbreiden via hoog-niveau functionele interfaces (@custom_op) of laag-niveau dispatch-logica (aten-bewerkingen). Dit zorgt voor compatibiliteit met evoluerende modelarchitecturen en aangepaste kernels.

Implementatiedetails

ShardTensor is gebouwd als een extensie op PyTorch's DTensor.

Dispatch-architectuur: Het onderschept bewerkingen op Python-niveau. Als een specifieke bewerking een domein-parallelle handler heeft, wordt deze uitgevoerd; anders valt het terug op DTensor-semantiek of standaard PyTorch-gedrag.
Communicatie: Het kader beheert collectieve bewerkingen (bijvoorbeeld all-reduce, all-gather) en "halo"-uitwisselingen (het ophalen van aangrenzende pixels van naburige apparaten) die vereist zijn voor bewerkingen zoals convolutie of normalisatie om numerieke consistentie te behouden.
Integratie: Het is ontworpen om compositabel te zijn met bestaande parallelismestrategieën (Data Parallelism en Model Parallelism), waardoor 2D of hogerdimensionale parallelismestrategieën mogelijk zijn (bijvoorbeeld het splitsen van de batch op één as en ruimtelijke dimensies op een andere as).

3. Belangrijkste Bijdragen

ShardTensor Framework: Een algemeen, open-source kader (beschikbaar via NVIDIA PhysicsNeMo) dat domeinparallelisme voor invoerdata onder een batchgrootte van één mogelijk maakt.
Nieuwe Abstractie: De introductie van "sharding-vormen" om dynamische invoertensor-distributies te hanteren, wat het onderscheidt van op gewichten gerichte parallelismetools zoals DTensor.
Niet-invasief programmeermodel: Een ontwerp dat gebruikers in staat stelt modelinvoer te omhullen met minimale code-aanpassingen, waardoor de noodzaak om lagen of modellen voor parallelisme te herschrijven wordt vermeden.
Compositabiliteit: Aangetoond vermogen om domeinparallelisme te combineren met data- en modelparallelisme op orthogonale mesh-assen.

4. Resultaten en Benchmarktests

Het artikel valideert ShardTensor via synthetische benchmarktests en real-world industriële toepassingen op NVIDIA Blackwell (GB200) en H100 GPU's.

Ring Attention: Bij zeer kleine sequentiegroottes overheerst de parallelisatie-overhead. Echter, bij zeer grote sequentiegroottes bereikt het systeem bijna lineaire sterke schaling met het GPU-aantal, zowel bij training als inferentie.
Vision Transformer (ViT):
- Sterke schaling: Bij hoge resoluties (bijvoorbeeld $4096^2$ ) is inferentie 15x sneller op 16 GPU's vergeleken met een enkele GPU. Training op $2048^2$ is 5x sneller met 8 GPU's.
- Geheugenefficiëntie: Het geheugengebruik schaalt kwadratisch voor 2D-data en kubisch voor 3D-data, wat bevestigt dat intermediaire activaties domineren. Sterke schaling met ShardTensor vermindert het geheugen per apparaat evenredig, waardoor het trainen van 3D-modellen met meer dan 1 miljard invoerpunten op standaardhardware mogelijk wordt.
Transolver (Automobiel-aerodynamica):
- Getraind op de DrivaerML-dataset met tot 1,2 miljoen punten per domein.
- Het systeem behield numerieke stabiliteit en concurrerende nauwkeurigheid (L2-fout voor druk en snelheid) vergeleken met single-GPU-baselines, zelfs toen de domeingrootte met factoren van 2, 4 en 8 toenam.
- De volledige voorverwerkingspijplijn werd eveneens geparaalleerd, waardoor end-to-end schaalbaarheid werd gewaarborgd.
StormScope (Weersvoorspelling):
- Een continentale schaalmodel (CONUS) met een resolutie van 3 km ( $1024 \times 1792$ rooster).
- Het piekgeheugengebruik (114 GB) overschreed de capaciteit van een enkele H100 GPU (80 GB).
- ShardTensor maakte stabiele training mogelijk door activaties te splitsen over 2 GPU's binnen 16 data-parallelle groepen. Het model convergeerde stabiel, volgend op de verlies-trajectorie van een single-GPU-baseline met lagere resolutie (6 km), waardoor het oplossen van individuele convectieve stormen mogelijk werd die eerder ontoegankelijk waren zonder het domein te verkleinen.

5. Betekenis en Claims

Het artikel claimt dat ShardTensor een fundamenteel knelpunt in SciML aanpakt: het onvermogen om te trainen en inferentie uit te voeren op data met de native resolutie die door wetenschappers wordt vereist.

Ontblokken van resolutie-beperkte werklasten: Het zet eerder onmogelijke berekeningen (vanwege geheugendekkels) om in hanteerbare taken, waardoor hoogwaardige training mogelijk wordt in gebieden zoals volumetrische medische beeldvorming, computationele stromingsdynamica en klimaatmodellering.
Compositabiliteit: Het verwijdert de afweging tussen datavolume, modelgrootte en resolutie. Wetenschappers kunnen nu tegelijkertijd schalen langs meerdere parallelisme-assen.
Toegankelijkheid: Door een niet-invasief programmeermodel te bieden, verlaagt het de instapdrempel voor practitioners die geen experts zijn in gedistribueerde systemen, in contrast met eerdere specifieke, architectuurgebonden paralleliseringsinspanningen.

Erkende Beperkingen

De auteurs merken bescheiden op dat het imperatieve, laag-voor-laag dispatch-model overhead op Python-niveau introduceert, waardoor het minder efficiënt is voor kleine bewerkingen of data met lage resolutie. De prestaties zijn ook afhankelijk van de bandbreedte van de interconnect. Bovendien hebben niet alle PyTorch-bewerkingen momenteel domein-parallelle dispatch-paden, en is volledige integratie met torch.compile voor statische grafiekoptimalisaties gaande.

Kortom, ShardTensor vertegenwoordigt een stap in de richting om hoge domeinparallelisme even gebruikelijk te maken in wetenschappelijk machine learning als data-parallelisme dat vandaag de dag is, en faciliteert het tijdperk van wetenschappelijke foundation-modellen.