Bridging the Gap Between Promise and Performance for Microscaling FP4 Quantization

Deze studie introduceert MR-GPTQ, een op de FP4-quantisatie toegesneden algoritme dat door het gebruik van bloksgewijze Hadamard-transformaties en geoptimaliseerde GPU-kernen de nauwkeurigheidskloof tussen belofte en prestatie van microscaling FP4-formaten overbrugt en aanzienlijke versnellingen op moderne GPU's realiseert.

De kern

De Kern: Een Belofte die nog niet waargemaakt werd

Stel je voor dat je een gigantische, slimme robot (een "Large Language Model" of LLM) hebt. Deze robot is heel slim, maar ook heel zwaar en traag. Om hem sneller en lichter te maken, willen we zijn kennis "samenvatten" in een kleiner formaat. Dit noemen we quantisatie.

Onlangs hebben chipmakers (zoals NVIDIA en AMD) een nieuw, super-efficiënt formaat beloofd: FP4. Dit is als het verpakken van de robot in een ultralichte, compacte koffer. De belofte was: "Dit maakt je robot 4x sneller en bespaart enorm veel ruimte, zonder dat hij dommer wordt."

Het probleem: In de praktijk bleek deze nieuwe koffer niet te werken zoals beloofd. Als je de robot erin stopte, werd hij vaak erg dom en maakte hij veel fouten. Het was alsof je een dure Ferrari in een kartonnen doos probeerde te vervoeren; hij past erin, maar hij rijdt niet meer.

Wat hebben de onderzoekers ontdekt?

De auteurs van dit paper (van o.a. IST Austria en Red Hat) hebben onder de motorkap gekeken en twee grote problemen gevonden:

1. De "NVFP4"-koffer (NVIDIA's versie): Deze koffer is te klein. Hij probeert de robot in blokken van 16 stukjes te verdelen. Het probleem is dat de robot soms "uitbijters" heeft (bijvoorbeeld een heel groot getal dat belangrijk is). Omdat de blokken zo klein zijn, wordt deze belangrijke informatie verdoofd door de standaard regels van de koffer. Het is alsof je een gigantische olifant probeert te verstoppen in een doosje voor hamsters; de olifant past er niet goed in en wordt platgedrukt.
2. De "MXFP4"-koffer (De open standaard): Deze koffer is iets groter (32 stukjes), maar hij gebruikt een heel stijve regel: hij mag alleen vermenigvuldigen met machten van 2 (zoals 2, 4, 8, 16). Dit is als proberen een schilderij te kopiëren, maar je mag alleen kleuren gebruiken die exact op de lijnen van een rooster vallen. Het resultaat is een wazig, onherkenbaar plaatje. De nauwkeurigheid zakt hierdoor drastisch.

De Oplossing: MR-GPTQ (De Slimme Verpakker)

De onderzoekers bedachten een nieuwe methode om deze koffers toch bruikbaar te maken. Ze noemen het MR-GPTQ.

Stel je voor dat je de robot (de data) eerst even draait en schudt voordat je hem in de koffer stopt.

• De "Rotatie" (Hadamard-transformatie): In plaats van de robot direct in de koffer te proppen, draaien ze hem eerst een beetje. Hierdoor verdelen ze de "grote" en "kleine" stukjes van de robot gelijkmatiger over de koffer. De "uitbijters" (die grote, lastige getallen) worden nu netjes verdeeld over de hele koffer in plaats van dat ze één plek blokkeren.
• Speciale regels per koffer: Ze hebben de verpakkingsspecificaties aangepast aan het type koffer. Voor de stijve MXFP4-koffer hebben ze een slimme truc bedacht om de schaal (de grootte van de getallen) beter af te stemmen, zodat de "roosterlijnen" niet meer in de weg zitten.

Het Resultaat: Snelheid én Slimheid

Met deze nieuwe methode (MR-GPTQ) en speciale software die ze hebben geschreven (genaamd QuTLASS), hebben ze de volgende resultaten behaald:

• Snelheid: Op de nieuwste grafische kaarten (zoals de NVIDIA B200 en RTX 5090) is de robot nu 2 tot 4 keer sneller dan voorheen, terwijl hij nog steeds slim blijft.
• Kwaliteit: De robot maakt bijna even weinig fouten als in zijn oorspronkelijke, zware vorm. Ze hebben de "domme" FP4-versie getransformeerd in een versie die net zo goed presteert als de duurdere, zwaardere versies.

De Metafoor: De Pizza en de Doos

Om het heel simpel te maken:

• De Pizza (De AI): Een hele grote, heerlijke pizza.
• De Oude Doos (FP16): Een enorme, zware doos. De pizza past perfect, maar de doos is zwaar om te dragen.
• De Nieuwe Doos (FP4): Een kleine, lichtgewicht doos. De belofte was: "We kunnen de pizza hierin doen zonder dat hij eruitziet alsof hij geplet is."
• Het Foutje: Als je de pizza zomaar in de kleine doos stopt, wordt hij een rommelige, onherkenbare lap (hij wordt "dom").
• De Oplossing (MR-GPTQ): De onderzoekers zeggen: "Wacht even, we snijden de pizza in een heel specifiek patroon en draaien de stukjes een beetje voordat we ze in de kleine doos leggen." Hierdoor past de pizza perfect in de kleine doos, blijft hij er lekker uitzien, en kun je hem nu veel sneller vervoeren.

Conclusie

Dit paper laat zien dat de nieuwe, snelle technologie (FP4) niet direct "plug-and-play" werkt. Maar met de juiste slimme aanpassingen (zoals het draaien van de data en het optimaliseren van de schaal), kunnen we de snelheid van de toekomstige chips volledig benutten zonder in te leveren op de intelligentie van de modellen. Het is een brug geslagen tussen de belofte van de hardware en de realiteit van de software.

Technische samenvatting

Probleemstelling

Recente hardware-versnellers van NVIDIA (Blackwell) en AMD introduceren microscaling 4-bit floating-point formaten, specifiek MXFP4 en NVFP4. Deze formaten beloven een revolutie in de inferentie van Large Language Models (LLM's) door de opslag en rekentijd aanzienlijk te verminderen ten opzichte van traditionele INT4-formaten.

Echter, de paper stelt vast dat er een groot gat bestaat tussen deze belofte en de werkelijke prestaties. Bestaande state-of-the-art kwantisatiemethoden (zoals GPTQ, SmoothQuant, RTN) presteren slecht op deze nieuwe formaten, wat leidt tot significante nauwkeurigheidsverliezen. De auteurs identificeren twee fundamentele oorzaken voor dit falen:

1. NVFP4 en uitbijters: NVFP4 gebruikt een kleine groepsgrootte (16 elementen). Dit neutraliseert effectief traditionele technieken voor het mitigeren van uitbijters (outliers), omdat de gedeelde schaal per groep te beperkt is om de extreme waarden goed te vertegenwoordigen zonder de rest van de groep te verstoren.
2. MXFP4 en schaalfouten: MXFP4 gebruikt een groepsgrootte van 32 en schaalt waarden af op machten van twee (E8M0-formaat voor de schaal). Deze "power-of-two" kwantisatie introduceert enorme kwantisatiefouten, vooral omdat de dynamische range van de schalen niet optimaal wordt benut door de grove grid van E8M0.

Methodologie: MR-GPTQ

Om deze kloof te dichten, stellen de auteurs Micro-Rotated-GPTQ (MR-GPTQ) voor. Dit is een aangepaste variant van het klassieke GPTQ-algoritme dat specifiek is ontworpen voor de unieke eigenschappen van FP4-formaten. De kerncomponenten zijn:

1. Block-wise Hadamard Transformaties (Micro-Rotaties):

   • In plaats van de gewichten en activaties direct te kwantiseren, worden ze eerst onderworpen aan een Hadamard-transformatie op blokniveau.
   • Dit "normaliseert" de verdeling van de gewichten en activaties, waardoor ze minder zwaar getaild (heavy-tailed) worden en beter passen bij de uniforme grids van de FP4-formaten.
   • De auteurs analyseren wiskundig dat rotaties de nauwkeurigheid voor MXFP4 verbeteren (door de uitbijters te verdelen), maar voor NVFP4 met standaard RTN (Round-to-Nearest) juist schadelijk kunnen zijn tenzij de schalen worden geoptimaliseerd.

2. Format-specifieke Schaaloptimalisatie:

   • Voor NVFP4: De methode optimaliseert de gedeelde schalen (tensor- en groepschalen) om de fouten die door de rotatie worden geïntroduceerd te compenseren.
   • Voor MXFP4: Er wordt een nieuwe "scale-fitting" techniek voorgesteld. Omdat de E8M0-grid te grof is voor de werkelijke data-range, wordt de exponent van de schaal aangepast (rescaling) om de grid beter af te stemmen op de data, wat de kwantisatiefout drastisch verlaagt.

3. Statische Activeringsherordening:

   • In plaats van dynamisch kolommen van de matrix te herschikken tijdens de inferentie (wat vertraging veroorzaakt), wordt de herordening statisch toegepast tijdens het kwantisatieproces. De kolommen worden na de kwantisatie weer teruggezet, waardoor de microscaling-groepsstructuur behouden blijft zonder runtime-overhead.

GPU Kernel Ondersteuning (QuTLASS)

Een cruciaal onderdeel van de bijdrage is de implementatie van QuTLASS, een set van hoog-presterende GPU-kernels voor NVIDIA Blackwell-architecturen (SM100/SM120).

• Fused Kernels: De "micro-rotatie" (Hadamard-transformatie) wordt niet als een aparte stap uitgevoerd, maar gefuseerd in de kwantisatie- en matrixvermenigvuldigingskernels.
• Online Rotatie: De rotatie van activaties gebeurt "online" met een zeer lichte overhead.
• Resultaat: De kernels bereiken een doorvoer die dicht bij het theoretische maximum ligt, zelfs met de extra rotatiestap.

Belangrijkste Resultaten

De auteurs hebben uitgebreide experimenten uitgevoerd op modellen zoals Llama-3 (1B tot 70B) en Qwen-3 (8B tot 32B) op NVIDIA B200 en RTX 5090 hardware.

Nauwkeurigheid:

• Stand van zaken: Standaard methoden (RTN) leiden bij MXFP4 tot een nauwkeurigheidsdaling van ongeveer 10% ten opzichte van FP16.
• MR-GPTQ Prestaties:
  • Voor NVFP4 herstelt GPTQ/MR-GPTQ de nauwkeurigheid tot 98-99% van de FP16-baseline.
  • Voor MXFP4 (de meest uitdagende vorm) slaagt MR-GPTQ erin de nauwkeurigheidsdaling te reduceren tot slechts 1-2% ten opzichte van NVFP4. Dit is een enorme verbetering ten opzichte van bestaande methoden.
  • Op grote modellen (70B+) bereiken beide formaten met MR-GPTQ een herstel van 98-99% van de FP16-nauwkeurigheid.

Prestaties (Snelheid):

• Layer-wise Speedup:
  • Op NVIDIA B200: Tot 3.6x sneller dan FP16.
  • Op RTX 5090: Tot 6x sneller dan FP16.
• End-to-End Speedup:
  • Op B200: 2.2x sneller.
  • Op RTX 5090: 4x sneller.
• Opmerkelijk is dat de MXFP4-implementatie met MR-GPTQ zelfs een hogere doorvoer kan bereiken dan een ideale NVFP4-matrixvermenigvuldiging, dankzij de efficiëntere schaalverwerking en grotere groepsgroottes.

Significantie en Conclusie

De paper concludeert dat FP4-kwantisatie niet automatisch een upgrade is boven INT4; zonder specifieke aanpassingen presteert het slecht. De belangrijkste bijdrage is het bewijs dat format-specifieke methoden (zoals MR-GPTQ) essentieel zijn om het potentieel van nieuwe hardware-formaten te ontsluiten.

Door de combinatie van wiskundige analyse (Hadamard-rotaties en schaaloptimalisatie) en systeemoptimalisatie (QuTLASS kernels), kunnen LLM's nu met FP4-kwantisatie worden uitgevoerd met een nauwkeurigheidsverlies dat verwaarloosbaar is, terwijl ze toch een aanzienlijke snelheidswinst behalen. Dit opent een nieuw front voor de afweging tussen nauwkeurigheid en prestaties in de inferentie van generatieve AI-modellen.