An Efficient Heterogeneous Co-Design for Fine-Tuning on a Single GPU

Each language version is independently generated for its own context, not a direct translation.

Stel je voor dat je een enorme, slimme robot (een "Large Language Model" of LLM) wilt leren een nieuwe vaardigheid, zoals het schrijven van gedichten in het Nederlands. Dit noemen we "fine-tuning". Het probleem is dat deze robot zo groot is dat hij niet in de "herinnering" (het geheugen) van je gewone computer past. Het is alsof je probeert een olifant in een kleine auto te proppen; de auto (je videokaart) is sterk genoeg om te rijden, maar hij is simpelweg te klein om de olifant te dragen.

De onderzoekers van deze paper, SlideFormer, hebben een slimme oplossing bedacht om deze olifant toch in de auto te krijgen, zonder dat je een dure vrachtwagen (een supercomputer) hoeft te huren.

Hier is hoe het werkt, vertaald naar alledaagse taal:

1. Het Probleem: De "Olifant in de Auto"

Normaal gesproken moet je de hele robot in het geheugen van je videokaart (GPU) hebben om hem te trainen. Maar moderne videokaarten hebben maar een beperkt geheugen (bijvoorbeeld 24 GB), terwijl de robot er 100 GB of meer nodig heeft.

De oude aanpak: Mensen probeerden de robot in stukjes te hakken en over meerdere computers te verspreiden, of ze gebruikten trucjes om de robot kleiner te maken (maar dan was hij minder slim).
Het nieuwe idee: Waarom niet de rest van de computer gebruiken? Je computer heeft vaak wel 256 GB aan gewone geheugen (RAM) en een snelle harde schijf. SlideFormer gebruikt die ruimte slim.

2. De Oplossing: Het "Schuifraam"-Principe

SlideFormer werkt als een schuifraam in een treinwagon.

De Schuifraam-Architectuur: In plaats van de hele robot in één keer in de auto te proppen, houden ze alleen het stukje dat op dat moment werkt in de auto.
- Stel je voor dat je een lange film bekijkt. Je hebt maar een klein scherm (de GPU). SlideFormer schuift het stukje film dat je nu bekijkt op het scherm, terwijl de rest van de film klaarstaat in de kast (het CPU-geheugen).
- Zodra het stukje op het scherm klaar is, schuift het naar de kast en komt het volgende stukje naar voren. Dit gebeurt zo snel dat je het niet merkt.

3. De Slimme Meester: De "Asynchrone Chef"

Het grootste probleem bij dit schuiven is dat de auto (GPU) vaak stilstaat en wacht tot het nieuwe stukje film uit de kast wordt gehaald. Dat is tijdverspilling.

SlideFormer's truc: Ze hebben een slimme "chef" (een asynchrone engine) die alles tegelijk doet.
- Terwijl de GPU bezig is met het rekenen aan het huidige stukje film, pakt de CPU alvast het volgende stukje uit de kast en bereidt het voor.
- Tegelijkertijd wordt het afgewerkte stukje terug naar de kast geschoven.
- Analogie: Het is alsof een kok (GPU) aan het koken is, terwijl een assistent (CPU) alvast de volgende ingrediënten wast en snijdt. De kok hoeft nooit te wachten; er is altijd iets te doen.

4. De "Geheugen-Organisator"

Om te voorkomen dat de kast rommelig wordt en ruimte verspillen, heeft SlideFormer een heel strak systeem:

Geen losse doosjes: In plaats van dat je voor elk stukje film een nieuw doosje zoekt (wat rommel en tijd kost), hebben ze een vaste rij van identieke doosjes. Zodra een doosje leeg is, wordt het direct opnieuw gebruikt. Dit voorkomt dat je geheugen "volloopt" met kleine, onbruikbare stukjes ruimte.
Slimme verpakking: Ze gebruiken speciale "gemeenschappelijke dozen" voor de berekeningen, zodat ze niet elke keer dubbel zoveel ruimte nodig hebben.

5. De Snelle Levering: De "Riolering" (GPUDirect)

Soms is de robot zo groot dat hij zelfs niet in de geheugenkast van de computer past, maar wel op de harde schijf (NVMe).

Normaal gesproken moet de data eerst naar de CPU en dan pas naar de GPU, wat traag is.
SlideFormer gebruikt een speciale "rupsband" (GPUDirect Storage) die de data rechtstreeks van de harde schijf naar de videokaart stuurt, zonder dat de CPU er tussen hoeft te komen. Het is alsof je goederen direct van het vliegtuig naar de vrachtwagen laadt, zonder ze eerst in het magazijn te leggen.

Wat levert dit op?

Dankzij deze slimme coördinatie kunnen mensen nu:

Enorme modellen trainen op één gewone computer: Je kunt nu een model van 123 miljard parameters (grootte van de slimste robots ter wereld) fine-tunen op een gewone gaming-computer met een RTX 4090 videokaart.
Veel sneller zijn: Ze zijn tot 6 keer sneller dan bestaande methoden.
Meer tegelijk doen: Je kunt grotere groepen gegevens tegelijk verwerken (grotere "batch sizes").
Betaalbaar blijven: Je hebt geen dure serverparken meer nodig. Iedereen met een goede PC kan nu meedoen.

Kortom: SlideFormer is als een magische trucsleutel die de beperkingen van je computer opheft. Het zorgt ervoor dat je videokaart nooit stilstaat, je geheugen perfect wordt gebruikt, en je de slimste AI-modellen kunt leren op je eigen bureau, zonder dat je een fortuin hoeft uit te geven.

Each language version is independently generated for its own context, not a direct translation.

Titel: Een Efficiënte Heterogene Co-Design voor Fine-Tuning op een Enkele GPU

Auteurs: Ruijia Yang en Zeyi Wen (HKUST-Guangzhou)

1. Het Probleem

Het fine-tunen van Large Language Models (LLMs) is essentieel voor domeinspecifieke aanpassingen, maar de huidige methoden stuiten op een ernstige geheugenbottleneck.

VRAM-beperking: Het fine-tunen van modellen (bijv. een 8B-parameter model) vereist vaak meer dan 128 GB GPU-geheugen (VRAM), wat ver buiten de capaciteit ligt van de meeste consumenten- en zelfs high-end GPUs (zoals de RTX 4090 met 24 GB).
De "VRAM-muur": Hoewel moderne GPUs voldoende rekenkracht hebben om grote modellen te verwerken, is het geheugen de beperkende factor. Dit belemmert de democratisering van LLM-fine-tuning voor individuen en kleine laboratoria zonder toegang tot GPU-clusters.
Bestaande oplossingen zijn ontoereikend:
- Distributie (Pipeline/Tensor Parallelism): Vereist meerdere GPUs.
- Parameter-efficiënte methoden (LoRA): Presteren vaak slechter dan full-parameter fine-tuning.
- Bestaande offloading-systemen (ZeRO-Offload, ZeRO-Infinity): Zijn ontworpen voor multi-GPU omgevingen, hebben overbodige overhead op één GPU, en synchroniseren vaak de CPU-updates met de GPU-werklast, waardoor de GPU inactief blijft.

2. Methodologie: SlideFormer

De auteurs stellen SlideFormer voor, een systeem dat een holistische heterogene co-design hanteert. Het doel is om de volledige hardware-platform (GPU, CPU, RAM, NVMe) te coördineren om de VRAM-beperking te doorbreken.

De architectuur rust op drie pijlers:

A. Light-Weight Asynchronous Engine (Layer-Sliding Architectuur)

In plaats van het hele model in het geheugen te houden, gebruikt SlideFormer een sliding window-benadering op laag-niveau (layer-granulariteit).

Asynchrone Pipelining: Zodra een laag ( $L_i$ ) zijn backpropagation op de GPU heeft voltooid, worden de gradiënten asynchroon overgebracht naar het CPU-geheugen (d2h).
Overlap: Terwijl de CPU de parameters ( $P_i$ ) bijwerkt met de optimizer, berekent de GPU de backpropagation voor de volgende laag ( $L_{i-1}$ ) en haalt de parameters voor $L_{i-2}$ alvast op (h2d).
Thread-based Engine: In tegenstelling tot process-based systemen (zoals LoHan) die IPC-overhead hebben, gebruikt SlideFormer een lichtgewicht thread-based engine met gescheiden CUDA-streams voor transfers en berekeningen, wat blokkering minimaliseert.
Beding voor efficiëntie: De berekeningstijd van de GPU moet groter zijn dan of gelijk zijn aan de som van de transfer- en update-tijden ( $T_{compute} \geq T_{transfer} + T_{update}$ ) om de GPU volledig te benutten.

B. Efficiënt Heterogeen Geheugenbeheer

Het systeem elimineert fragmentatie en dynamische toewijzing door vooraf toegewezen buffers te gebruiken.

Pre-allocated GPU Cache Queue: De GPU bevat slechts een klein venster van actieve lagen (parameters en gradiënten). Gebruikte eenheden worden direct hergebruikt, wat fragmentatie voorkomt en het VRAM-gebruik minimaliseert.
Gedeelde CPU-buffers: Op de CPU worden gradiënten en type-conversies (FP32 naar BF16/FP16) gedeeld in vaste buffers. Dit verlaagt het piekgebruik van CPU-geheugen met meer dan 25% door dubbele kopieën te vermijden.
Sliding Activations: Activaties worden asynchroon naar CPU of NVMe verplaatst na de forward pass en pas weer opgehaald voor de backward pass, waardoor VRAM voor activaties beperkt blijft tot een klein venster.
Layer-Adam Optimizer: Optimizer-states worden opgeslagen in het host-geheugen en kunnen optioneel naar NVMe worden verplaatst.

C. Geïntegreerde Geavanceerde I/O en Kernels

GPUDirect Storage (GDS): SlideFormer is de eerste die GDS integreert voor LLM-fine-tuning. Dit stelt een directe data-paath tussen NVMe en GPU in, waarbij de CPU als "bounce buffer" wordt omzeild. Dit verlaagt CPU-uitvoer en PCIe-concurrentie.
Geoptimaliseerde Triton Kernels: Het systeem gebruikt aangepaste Triton-kernels voor operaties zoals RoPE, RMSNorm en SwiGLU.
Fused LinearCrossEntropy (LCE): Een kritieke innovatie. Voor modellen met grote vocabulaires (zoals Llama-3.1) consumeert de logit-tensor vaak meer geheugen dan alle andere activaties. SlideFormer fuseert de projectie en verliesberekening in één kernel, waardoor het geheugenvoetafdruk van de outputlaag met >80% wordt verlaagd zonder nauwkeurigheidsverlies.

3. Belangrijkste Resultaten

SlideFormer werd geëvalueerd op een enkele RTX 4090 (24 GB) en een A100 (80 GB), vergeleken met baselines zoals ZeRO-Offload, ZeRO-Infinity, ColossalAI en LoHan.

Doorvoersnelheid (Throughput): SlideFormer bereikt 1,40x tot 6,27x hogere doorvoersnelheid dan bestaande methoden.
Geheugenefficiëntie:
- GPU-geheugen: Verlaagt het VRAM-gebruik met >50% vergeleken met ZeRO-Offload.
- CPU-geheugen: Verlaagt het CPU-gebruik met ~40% dankzij gedeelde buffers.
Schaalbaarheid:
- Het systeem kan modellen van >123B parameters fine-tunen op een enkele RTX 4090 (met NVMe-offloading).
- Het ondersteunt 8x grotere batch sizes en 6x grotere modelgroottes dan bestaande frameworks.
Hardware-onafhankelijkheid: SlideFormer behaalt >95% van de piekprestaties (ten opzichte van non-offloading training) op zowel NVIDIA (RTX 4090, A100) als AMD (RX 7900 XT) GPU's.
NVMe Offloading: Voor modellen die groter zijn dan het CPU-geheugen, kan NVMe worden gebruikt. De auteurs tonen aan dat het offloaden van optimizer-states effectiever is dan het offloaden van activaties voor kleinere modellen, terwijl voor zeer grote modellen een combinatie optimaal is.

4. Betekenis en Impact

Democratisering van LLM-fine-tuning: SlideFormer maakt het mogelijk voor individuen en kleine onderzoeksgroepen om state-of-the-art modellen (zoals Llama-3, Qwen, Mistral) op hun eigen high-end PC's (met één GPU en voldoende RAM) te fine-tunen, zonder afhankelijk te zijn van dure cloud-clusters.
Paradigmaverschuiving: Het paper toont aan dat door een zorgvuldige co-design van hardware en software (CPU, GPU, NVMe), de "VRAM-muur" effectief kan worden doorbroken.
Praktische toepasbaarheid: In tegenstelling tot eerdere prototypes die vaak beperkt waren tot specifieke modellen (bijv. alleen GPT-2) of onrealistische loss-functies gebruikten, is SlideFormer compatibel met de nieuwste architecturen (Llama, Qwen) en standaard trainingsdoelen.

Kortom, SlideFormer bewijst dat full-parameter fine-tuning van enorme modellen op één enkele GPU niet alleen mogelijk is, maar ook extreem efficiënt kan worden uitgevoerd door de geheugenhiërarchie en berekeningsstromen slim te synchroniseren.