🤖 machine learning

FairyFuse: Multiplication-Free LLM Inference on CPUs via Fused Ternary Kernels

FairyFuse is een inferentiesysteem dat multiplication-vrije uitvoering van grote taalmodellen op CPU's mogelijk maakt door ternaire gewichten te gebruiken en acht sub-GEMV-bewerkingen te fuseren tot één AVX-512-lus, wat resulteert in een aanzienlijke versnelling en verbeterde geheugenefficiëntie zonder kwaliteitsverlies.

Oorspronkelijke auteurs: Fei Zuo, Xiaoyan Xi, Quanyi Zeng, Feiyu Wang, Ho Fai Leung

Gepubliceerd 2026-04-24

📖 4 min leestijd☕ Koffiepauze-leesvoer

CC0 1.0

Oorspronkelijke auteurs: Fei Zuo, Xiaoyan Xi, Quanyi Zeng, Feiyu Wang, Ho Fai Leung

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

FairyFuse: Het Versnellen van AI op Gewone Computers zonder "Vermenigvuldigen"

Stel je voor dat je een enorme, slimme robot (een Large Language Model of LLM) hebt die je wilt laten werken op je gewone laptop of desktopcomputer, in plaats van op een dure, energievretende server in een datacentrum. Het probleem? Deze robots zijn zo zwaar dat ze vastlopen op de snelheid van het geheugen van je computer. Het is alsof je probeert een vrachtwagen vol met boeken te verplaatsen, maar de deur is zo smal dat het maar één boek per keer kan passeren.

De onderzoekers van FairyFuse hebben een slimme oplossing bedacht om dit probleem op te lossen, specifiek voor computers zonder speciale grafische kaarten (GPUs). Hier is hoe het werkt, vertaald naar alledaagse taal:

1. Het Probleem: De "Vermenigvuldigings"-Valstrik

Normaal gesproken moet een computer bij het berekenen van een antwoord duizenden getallen met elkaar vermenigvuldigen. Dit is zwaar werk voor de processor en kost veel tijd en energie.

De huidige oplossing: Mensen maken de getallen in de robot "kleiner" (kwantisatie), bijvoorbeeld van 4 decimalen naar 4 bits. Maar de computer moet die kleine getallen nog steeds "ontcijferen" en dan toch vermenigvuldigen. Het is alsof je een pakketje verpakt in een klein doosje, maar de bezorger moet het pakketje toch weer uitpakken en tellen voordat hij het kan leveren.

2. De Oplossing: De "Drie-Kleuren" Methode (Ternair)

FairyFuse gebruikt een heel radicale aanpak. In plaats van duizenden verschillende getallen, gebruiken ze slechts drie opties voor elk gewicht in de robot:

+1 (Voeg erbij)
-1 (Trek er af)
0 (Doe niets)

Dit is als het verschil tussen een kok die duizenden verschillende kruidenmengsels moet afwegen (vermenigvuldigen) en een kok die alleen maar moet beslissen: "Voeg een snufje zout toe", "Haal een snufje zout weg" of "Doe niets".

Het grote voordeel: Je hoeft niet meer te vermenigvuldigen! Je hoeft alleen maar op een knop te drukken om iets op te tellen of af te trekken. Dit is veel sneller en vereist minder rekenkracht.

3. De Innovatie: De "Magische Slang" (Fused Kernels)

Maar er was een probleem. De robot die ze gebruikten (Fairy2i) was zo ontworpen dat hij acht verschillende berekeningen tegelijk moest doen voor elk stukje tekst.

De oude manier: De computer zou acht keer dezelfde boeken uit de kast halen, acht keer de deur openen en acht keer de bezorger laten wachten. Dit kostte te veel tijd.
De FairyFuse-methode: Ze hebben een "magische slang" bedacht (de Fused Kernel). In plaats van acht keer heen en weer te rennen, pakt de computer één keer alle boeken, en doet hij alle acht de berekeningen in één enkele, super-snelle beweging.

Ze gebruiken speciale instructies in de processor (AVX-512) die werken als een magische schaar: ze knippen precies de juiste stukjes uit de data en plakken ze direct aan elkaar, zonder ooit te vermenigvuldigen.

4. Waarom is dit zo snel op een gewone computer?

Je zou denken dat dit sneller is op een supercomputer (GPU), maar dat is verrassend niet zo.

Op een GPU: De snelheid is beperkt door hoe snel de data kan worden opgehaald, maar de GPU heeft zo'n enorme bandbreedte (een superbrede snelweg) dat het "kleiner maken" van de data weinig verschil maakt. Het is alsof je een fiets op een snelweg zet; het helpt niet echt om sneller te zijn.
Op een CPU (gewone computer): Hier is de snelweg smal (beperkte geheugenbandbreedte). Door de data 16 keer kleiner te maken (van 32 bits naar 2 bits), past er veel meer op die smalle weg. De robot kan nu razendsnel vooruitkomen omdat hij niet meer vastloopt in de file.

5. Het Resultaat: Sneller dan de concurrentie

De onderzoekers hebben dit getest op een gewone Intel-server (een krachtige computer, maar geen dure AI-chip).

Snelheid: FairyFuse kon 32,4 woorden per seconde genereren.
Vergelijking: Dit is 1,24 keer sneller dan de beste bestaande software (llama.cpp) die werkt met 4-bit kwantisatie.
Kwaliteit: De antwoorden waren bijna net zo goed als de originele, ongekwalificeerde robot. Het verschil in "slimheid" was verwaarloosbaar klein.

Samenvatting in één zin

FairyFuse is als het vervangen van een zware, trage vrachtwagen die constant moet vermenigvuldigen, door een lichtgewicht, elektrische scooter die alleen maar vooruit en achteruit kan rijden; hierdoor kan je slimme AI-assistent razendsnel werken op je gewone laptop, zonder dat je een dure server nodig hebt.

Dit maakt het mogelijk om privacy-bewuste, offline AI-assistenten te bouwen die echt snel en efficiënt zijn op de hardware die we al in huis hebben.

Probleemstelling

Grote Taalmodellen (LLMs) worden steeds vaker gedeployeerd op CPU-only platformen, zoals lokale apparaten en privacygevoelige edge-servers. Op deze platformen is geheugenbandbreedte de dominante bottleneck voor autoregressieve token-generatie, niet de rekenkracht.

Huidige beperkingen: Bestaande systemen gebruiken vaak kwantisatie (bijv. 4-bit) om het geheugenverbruik te verkleinen, maar de gewichten worden tijdens de inferentie toch weer gedequantiseerd naar floating-point en vermenigvuldigd. Hierdoor gaat het potentieel van bit-width besparingen grotendeels verloren.
Ternaire gewichten: Gewichten in de set $\{-1, 0, +1\}$ bieden een radicale oplossing: ze vereisen slechts 2 bits per gewicht (een 16x compressie t.o.v. FP32) en vervangen vermenigvuldigingen door conditionele optellingen of aftrekkingen. Echter, bestaande implementaties (zoals de referentie-runtime van Fairy2i of llama.cpp) exploiteren deze ternaire structuur niet op instructieniveau; ze gebruiken nog steeds standaard floating-point vermenigvuldigingen of lookup-tabellen die cache-bandbreedte verbruiken.

Methodologie: FairyFuse

FairyFuse is een inferentie-systeem dat specifiek is ontworpen voor Fairy2i-modellen (complex-waardige ternaire LLMs) en deze ternaire structuur vertaalt naar vermenigvuldigingsvrije uitvoering op commodity x86 CPU's.

1. Kernalgoritme (Ternaire GEMV):

Packing: Zestien ternaire gewichten ( $\{-1, 0, +1\}$ ) worden gepakt in één 32-bit woord (2 bits per gewicht).
Decoding: In plaats van lookup-tabellen (zoals bij T-MAC) of gedequantiseerde vermenigvuldigingen, gebruikt FairyFuse de BMI2-instructie _pext_u32 om positieve en negatieve maskers in één cyclus te extraheren.
Accumulatie: De berekening wordt uitgevoerd met AVX-512 gemaskeerde instructies (_mm512_mask_add_ps en _mm512_mask_sub_ps).
- Als het gewicht +1 is: optellen.
- Als het gewicht -1 is: aftrekken.
- Als het gewicht 0 is: niets doen (no-op).
Resultaat: De innerlijke lus bevat nul floating-point vermenigvuldigingen en nul lookup-tabellen.

2. Gefuseerde Widely-Linear Kernel:
Fairy2i-modellen gebruiken "widely-linear" transformaties die een complex lineaire laag ontleden in acht gekoppelde reëel-waardige sub-GEMV's (General Matrix-Vector Multiplications).

Een naïeve implementatie zou deze acht berekeningen als aparte threads of lussen uitvoeren, wat leidt tot herhaald laden van activaties en synchronisatie- overhead.
FairyFuse fuseert deze acht sub-GEMV's in één enkele row-parallelle AVX-512 lus. Dit wordt mogelijk gemaakt door vier ontwerpbeslissingen:
1. Maskerhergebruik (O1): Eén gedecodeerd maskerpaar dient zowel het reële als het imaginaire pad.
2. Input-vector hergebruik (O2): Activaties worden één keer geladen en gedeeld over alle acht sub-GEMV's.
3. Sign-swapping aliasing (O3): Complex conjugatie wordt behandeld als een vooraf berekende pointer-switch in plaats van per-lane negatie.
4. Register-resident accumulatie (O4): Alle partiële sommen blijven in registers tot de uiteindelijke reductie, wat DRAM-traffic elimineert.

Belangrijkste Bijdragen

Eerste multiplication-free GEMV op x86: Implementatie van een ternaire gewicht-kernel die uitsluitend gebruikmaakt van gemaskeerde AVX-512 optellingen en aftrekkingen, zonder floating-point vermenigvuldigingen of lookup-tabellen.
Gefuseerde Widely-Linear Kernel: Consolidatie van de acht sub-GEMV's van complex-waardige lagen in één SIMD-vriendelijke lus, wat een snelheidswinst van 1.55x oplevert ten opzichte van niet-gefuseerde uitvoering.
Systematische Validatie: Een volledige evaluatie die aantoont dat extreme kwantisatie (2-bit) CPUs de natuurlijke target maakt, in plaats van GPUs, door de verschuiving van geheugen-bound naar reken-bound operaties.

Resultaten

De evaluatie is uitgevoerd op een Intel Xeon 8558P (48 cores, ~200 GB/s bandbreedte) met een 7B-parameter model (LLaMA-2-7B).

Snelheid: FairyFuse bereikt 32.4 tokens per seconde. Dit is 1.24x sneller dan de huidige state-of-the-art llama.cpp Q4_K_M (4-bit) en 1.61x sneller dan Q2_K, ondanks dat FairyFuse een vergelijkbare geheugengrootte heeft (3.3 GB vs 2.8 GB voor Q2_K).
Kernprestaties: De ternaire kernel toont een 29.6x snelheidswinst op één socket vergeleken met FP32, en tot 54.4x bij gebruik van alle 48 threads (door superlineaire schaling wanneer het werkset in de cache past).
Kwaliteit: De kwaliteit is bijna verliesvrij:
- WikiText-2 Perplexity: 5.52 (vs. 5.47 voor FP16; Q4_K_M is 5.68).
- Downstream Accuracy: 66.0% (vs. 67.3% voor FP16; Q4_K_M is 65.1%).
Architecturale Analyse (Roofline):
- CPU: De 16x data-compressie verhoogt de rekenintensiteit (AI) van 0.25 naar 8.0, wat de kernel verschuift van de geheugen-bound regio naar de reken-ridge van de CPU. Dit verklaart de enorme snelheidswinst.
- GPU: Op GPU's (zoals NVIDIA H200) is de bandbreedte zo hoog dat compressie weinig voordeel biedt. Bovendien ontbreekt er op GPU's een efficiënte equivalent voor de _pext_u32 instructie, waardoor de ternaire decode op GPU's zelfs 130x trager is dan FP16.

Betekenis en Conclusie

FairyFuse bewijst dat CPUs de ideale platformen zijn voor extreme kwantisatie (zoals ternaire gewichten) van LLMs, mits de software de hardware-instructies correct benut.

Het paper toont aan dat het elimineren van vermenigvuldigingen via ternaire arithmetiek de geheugenbandbreedte-bottleneck op CPU's effectief oplost.
Het biedt een praktische route voor het draaien van miljarden-parameter modellen op privacy-vriendelijke, offline apparaten zonder discrete GPU's.
De aanpak is uniek omdat hij de complex-waardige structuur van moderne kwantisatie-methoden (Fairy2i) direct vertaalt naar een geoptimaliseerde, vermenigvuldigingsvrije hardware-pijplijn, in plaats van te vertrouwen op generieke dequantisatie of inefficiënte lookup-tabellen.