QFT: Quantized Full-parameter Tuning of LLMs with Affordable Resources

Het paper introduceert QFT, een framework dat volledige parameter-tuning van grote taalmodellen mogelijk maakt op betaalbare hardware door alle trainingsstaten naar INT8 te quantiseren en een hybride quantisatiestrategie te gebruiken die de prestaties behoudt terwijl het het geheugengebruik tot 21% van de standaardoplossing reduceert.

De kern

QFT: De "Slimme Verpakking" voor het Trainen van Super-Intelligente Computers

Stel je voor dat je een enorme, hyper-intelligente robot wilt trainen om slimme gesprekken te voeren, gedichten te schrijven of complexe problemen op te lossen. Deze robot heet een "Large Language Model" (LLM). Het probleem? Om deze robot te trainen, heb je een datacenter nodig met zo'n 20 tot 30 dure, krachtige videokaarten (GPUs). Dat is voor de meeste mensen of bedrijven net zo onbetaalbaar als een raket naar de maan.

De auteurs van dit papier, QFT (Quantized Full-parameter Tuning), hebben een oplossing bedacht die dit probleem oplost. Ze zeggen eigenlijk: "Waarom moeten we alles in zwaar, duur gewicht bewaren als we het ook in een lichtgewicht, slimme verpakking kunnen doen?"

Hier is hoe het werkt, vertaald naar alledaagse taal:

1. Het Probleem: De Zware Koffer

Normaal gesproken trainen mensen deze robots alsof ze alles in zware stalen koffers (FP32-getallen) bewaren. Elke gewicht, elke gedachte en elke herinnering die de robot leert, wordt in deze zware koffers gestopt.

• Gevolg: Je hebt een gigantische vrachtwagen (een dure GPU) nodig om deze koffers te vervoeren. Als je een robot van 7 miljard parameters wilt trainen, heb je minimaal 100 GB aan geheugen nodig. Dat past niet in een gewone computer.

2. De Oplossing: De "QFT"-Verpakking

QFT is als een meester-verpakkingsbedrijf. Ze zeggen: "Laten we al die zware stalen koffers vervangen door lichtgewicht, opvouwbare dozen (INT8-getallen)."

• Het idee: Ze slaan alles op in een compacte, 8-bits formaat. Geen zware dubbele kopieën meer.
• Het resultaat: De hele lading past nu in een kleine auto (een gewone, betaalbare GPU zoals een A6000). Je kunt dezelfde robot trainen met slechts 30 GB geheugen. Dat is een besparing van 79%!

3. De Uitdaging: Hoe zorg je dat het niet "lekkend" wordt?

Als je dingen in een lichte doos verpakt, loop je het risico dat ze beschadigen of dat de robot "dommer" wordt. De auteurs hebben twee slimme trucjes bedacht om dit te voorkomen:

Trucje A: De "Stabiele Bestuurder" (De Lion Optimizer)

Stel je voor dat je een auto bestuurt. Normaal gebruik je een complexe navigatie (Adam-optimizer) die constant snelheid en richting aanpast, maar die heeft veel zware apparatuur nodig.
QFT gebruikt in plaats daarvan Lion.

• De Analogie: Lion is als een ervaren bestuurder die alleen naar het teken van de weg kijkt (gaat het vooruit of achteruit?) en niet naar de exacte snelheid. Omdat hij alleen kijkt of je "links" of "rechts" moet, maakt het niet uit als je de exacte snelheid iets afrondt (kwantiseren).
• Wetenschap: De auteurs bewijzen wiskundig dat deze manier van besturen zo robuust is, dat het verpakt in een lichte doos (INT8) precies hetzelfde resultaat geeft als de zware versie.

Trucje B: De "Uitzonderingen Bewaren" (Hybride Kwaliteit)

Soms zijn er in de data een paar heel rare, extreme waarden (uitbijters). Stel je voor dat je een foto verkleint. Meestal gaat dat prima, maar als er één pixel op de foto staat die extreem fel is (bijvoorbeeld een felle flits), en je verkleint de foto, dan wordt die flits een vage vlek.

• Het probleem: Bij het trainen van robots zijn deze "flitsen" (uitbijters) vaak de allerbelangrijkste informatie. Als je die verliest, wordt de robot dom.
• De oplossing: QFT gebruikt een hybride verpakking.
  • 99% van de data (de gewone pixels) wordt strak opgevouwen in de lichte doos.
  • De 1% van de "flitsen" (de kritieke uitzonderingen) wordt apart bewaard in een speciale, kleine, maar dure doos (in float-formaat).
• Voordeel: Je hebt de meeste ruimtebesparing, maar je mist nooit de belangrijkste details. Je hoeft geen volledige zware kopie van de hele foto te bewaren.

4. Het Resultaat: Een Revolutie voor Iedereen

Door deze twee trucjes te combineren met een slimme manier om de "stroom" van informatie te regelen (een stapel-systeem dat heel snel werkt), kunnen ze nu:

• Een robot van 7 miljard parameters trainen op één enkele, betaalbare videokaart.
• De kwaliteit van de robot is net zo goed als die van de robots die in dure datacenters worden getraind.
• Geen speciale, dure hardware nodig hebben (zoals de nieuwste FP8-chips), maar werken met standaard hardware die je al hebt.

Kortom:
QFT is als het vinden van een manier om een olifant in een kleine auto te vervoeren zonder dat de olifant kleiner of zwakker wordt. Ze doen dit door de olifant in een slimme, opvouwbare pakking te stoppen en alleen de belangrijkste botten apart te bewaren. Hierdoor kan bijna iedereen nu meedoen aan de AI-revolutie, zonder een fortuin uit te geven aan hardware.

Technische samenvatting

Probleemstelling

Grote Taalmodellen (LLMs) hebben een enorme impact gehad op het gebied van Natural Language Processing. Het fijnafstemmen (fine-tuning) van deze vooraf getrainde modellen op downstream-taken is essentieel voor prestaties, maar dit proces is extreem rekenintensief en duur.

• Huidige beperking: Volledige parameter-fijnafstemming (Full-Parameter Fine-Tuning) vereist het opslaan van alle modeltoestanden (gewichten, gradiënten en optimizer-toestanden zoals momentum en variantie) in FP32-formaat. Voor een model zoals LLaMA-7B met de Adam-optimizer betekent dit een geheugenvraag van ongeveer 104 GB, wat alleen haalbaar is met zeer dure, high-end GPU's.
• Beperkingen van bestaande oplossingen:
  • Parameter-Efficient Fine-Tuning (PEFT) zoals LoRA slaat geheugen, maar heeft een beperkt representatief vermogen en presteert vaak slechter dan volledige afstemming.
  • Mixed-precision training (FP16) versnelt de berekening, maar vereist nog steeds een FP32-kopie van de gewichten voor updates, waardoor het geheugenprobleem niet volledig wordt opgelost.
  • Bestaande kwantisatie-methoden (zoals Bitsandbytes of QLoRA) richten zich vaak op inferentie of behouden FP32-gewichten tijdens training, waardoor ze geen volledige geheugenreductie bieden voor volledige afstemming.

Methodologie: QFT Framework

De auteurs stellen QFT (Quantized Full-parameter Tuning) voor, een framework dat alle trainingsstaten (gewichten, gradiënten en optimizer-toestanden) kwantiseert en opslaat in INT8-formaat. Dit maakt volledige afstemming mogelijk op betaalbare hardware (bijv. een enkele NVIDIA A6000 met <30 GB VRAM).

Om de trainingsprestaties te waarborgen ondanks de kwantisatie, introduceert QFT drie kerncomponenten:

1. Robuuste Optimizer: Lion

In plaats van de standaard Adam-optimizer (die momentum en variantie bijhoudt), gebruikt QFT de Lion-optimizer.

• Waarom Lion? Lion houdt alleen momentum bij (geen variantie) en gebruikt een sign-operatie voor updates. Dit resulteert in updates met een consistente grootte.
• Theoretisch bewijs: De auteurs bewijzen wiskundig dat Lion zeer robuust is tegen kwantisatie. Omdat de updategrootte consistent is, is de kans dat de teken van de update verandert door kwantisatie-error verwaarloosbaar klein (minder dan 5% kans op tekenflip bij een bepaalde drempel). Dit elimineert de noodzaak om optimizer-toestanden in FP32 te houden.

2. Hybride Feature Kwantisatie voor Gewichten

Gewichten kwantiseren is lastiger dan gradiënten omdat de verdeling van gewichten extreme "outliers" bevat die cruciaal zijn voor de representatie, terwijl de meeste waarden dicht bij elkaar liggen.

• Hybride aanpak: QFT deconstrueert de gewichtenmatrix $W$ in een dichte matrix ($D$) en een spare matrix ($S$).
  • De dichte matrix (99% van de waarden) wordt uniform gekwantiseerd naar INT8.
  • De spare matrix (de top 1% van de kritieke outliers) blijft in FP32-formaat.
• Voordeel: Dit behoudt de nauwkeurigheid van de updates zonder de volledige FP32-kopie van de gewichten te vereisen (zoals bij mixed-precision training). De outliers worden efficiënt opgeslagen in een compact formaat (zoals CSR).

3. Integer Training Pipeline met Stack-based Gradiënten

Omdat standaard frameworks (zoals PyTorch) gradiënten niet direct op integer-variabelen kunnen berekenen, ontwerpen de auteurs een nieuwe pipeline:

• Forward Pass: Gewichten worden "on-the-fly" gede-quantiseerd naar FP32 voor berekening, maar opgeslagen als INT8.
• Backward Pass: Gradiënten worden berekend via de kettingregel. In plaats van deze direct in het geheugen te houden voor elke laag, worden ze op een globale stack geplaatst in omgekeerde volgorde van de forward pass.
• Efficiëntie: Tijdens de parameter-update worden de gradiënten in $O(1)$ tijd van de stack gehaald (pop). Dit elimineert de afhankelijkheid van FP32-automatische differentiatie voor integer-gebaseerde training.

Belangrijkste Bijdragen

1. QFT Framework: Een volledig kwantiserend framework voor volledige parameter-fijnafstemming dat alle toestanden in INT8 opslaat, wat een drastische geheugenreductie mogelijk maakt.
2. Theoretische Validatie: Een wiskundig bewijs dat de Lion-optimizer inherent robuust is tegen kwantisatie van gradiënten en momentum.
3. Hybride Kwantisatie: Een methode die kritieke outliers in gewichten behoudt terwijl de rest wordt gekwantiseerd, waardoor nauwkeurige updates mogelijk zijn zonder FP32-backups.
4. Integer Pipeline: Een innovatieve stack-based gradiëntstroom met $O(1)$ complexiteit die integer-backpropagation mogelijk maakt.

Resultaten

De auteurs hebben QFT getest op LLaMA-2 modellen (7B en 13B) met instructie-tuning.

• Geheugenefficiëntie:
  • QFT reduceert het geheugengebruik voor modeltoestanden tot 21% van de standaard FP32 Adam-oplossing.
  • Het fine-tunen van een LLaMA-7B model vereist slechts <30 GB VRAM, wat mogelijk is op een enkele consumer-grade GPU (A6000).
  • Ter vergelijking: Standaard Adam vereist ~104 GB; Bitsandbytes ~66 GB.
• Prestaties:
  • Few-shot benchmarks: QFT bereikt prestaties die vergelijkbaar zijn met volledige FP32-fijnafstemming (FT-Adam) en overtreft LoRA en andere kwantisatie-methoden (zoals FT-Bnb).
    • Voorbeeld (LLaMA-2-7B): QFT scoort 57.4 gemiddeld, vergeleken met 58.0 voor FT-Adam en 56.2 voor LoRA.
  • Conversatie (MT-Bench): QFT behaalt een score van 5.95 (7B) en 6.27 (13B), wat zeer dicht in de buurt komt van de FP32-baselines (6.08 en 6.46) en aanzienlijk beter is dan LoRA.
  • Convergentie: De trainingsverliescurves tonen aan dat QFT convergeert op een vergelijkbaar niveau met FP32-training.
• Doorvoer: Er is een lichte toename in trainingstijd (1.2x - 1.3x) door de overhead van kwantisatie/de-kwantisatie, maar dit wordt gezien als een aanvaardbare trade-off voor de enorme geheugenwinst.

Betekenis en Impact

QFT is een doorbraak omdat het volledige parameter-fijnafstemming democratiseert.

• Toegankelijkheid: Het maakt het mogelijk om state-of-the-art LLM's op te trainen met middelen die beschikbaar zijn voor onderzoekers en bedrijven zonder toegang tot clusters van high-end GPU's.
• Prestatie vs. Kosten: Het lost het compromis op tussen de hoge prestaties van volledige afstemming en de lage kosten van PEFT.
• Hardware-onafhankelijkheid: Door standaard INT8 te gebruiken (in plaats van gespecialiseerde FP8-hardware), kan QFT op bestaande mid- en low-end GPU's worden uitgevoerd.

Samenvattend biedt QFT een praktische, theoretisch onderbouwde oplossing om de geheugenbarrière voor het trainen van grote taalmodellen te doorbreken, zonder in te leveren op modelkwaliteit.