🔬 condensed matter

A Modern Multimodal Assistant on a 6 GB 2011 GPU: Stage-Validated, All-GPU CUDA Inference for Fermi

Dit artikel demonstreert de haalbaarheid van het volledig draaien van een moderne multimodale assistent op een 2011 6GB Fermi GPU door een volledig op de GPU gebouwde inference-engine te ontwerpen die hardwarebeperkingen overwint via geoptimaliseerde dequantized GEMMs, gechunkte recurrente lagen en geheugenefficiënte attention-kernels, waarmee end-to-end beeld-vraag beantwoording in 1,7 seconden wordt bereikt.

Oorspronkelijke auteurs: A. C. Opus, J. Q. Lu

Gepubliceerd 2026-07-17

📖 6 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: A. C. Opus, J. Q. Lu

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

Stel je voor dat je een superintelligent robotbrein hebt dat plaatjes kan zien en vragen over die plaatjes kan beantwoorden. Normaal gesproken zijn deze hersenen zo groot en hongerig naar stroom dat ze een enorme, dure computer nodig hebben om te draaien, of dat ze opgedeeld moeten worden zodat delen van het brein in het geheugen van de computer leven terwijl andere delen op de processor leven. Maar wat als je zo'n superbrein op een computeronderdeel wilt draaien dat veertien jaar oud is? Dat is de uitdaging waar dit artikel een aanpak voor biedt. Het is alsoals proberen een moderne, high-definition videogame te draaien op een laptop uit 2011. Het kernidee hier is "inferentie", wat gewoon een deftig woord is voor het feit dat de robot daadwerkelijk denkt en een vraag beantwoordt nadat hij is onderwezen. De vraag in dit artikel is: kunnen we een moderne, beeldlezende AI volledig laten draaien op een zeer oude, zwakke videokaart zonder hulp nodig te hebben van de hoofdcomputer? Om dit te doen, moesten de onderzoekers ongelooflijk slim zijn in hoe ze de wiskunde organiseerden, omdat de oude kaart veel van de speciale hulpmiddelen mist die moderne kaarten wel hebben.

Het verhaal in dit artikel gaat over een team van ingenieurs die een gloednieuwe, moderne AI-assistent genaamd MiniCPM-V-4.6 hebben genomen en deze hebben gedwongen om te draaien op een NVIDIA-videokaart uit 2011 (de Tesla C2075) die slechts 6 GB aan geheugen heeft. Normaal gesproken wordt deze kaart als "verlaten" beschouwd door de softwarewereld, wat betekent dat er niemand meer nieuwe programma's voor schrijft. De onderzoekers wilden zien of ze het hele systeem volledig op deze oude kaart konden laten werken, zonder dat er gegevens heen en weer gestuurd hoeven te worden naar de hoofdcomputer. Ze slaagden erin, maar niet door te gokken; ze slaagden erin door alles te meten en te beseffen dat hun eerste vermoedens vaak fout waren.

Dit is wat ze ontdekten en hoe ze het deden:

1. De "Oude Gereedschappen" waren beter dan de Nieuwe
Het team begon met het proberen te schrijven van hun eigen aangepaste wiskundige tools (kernels) om de AI sneller te laten draaien. Ze dachten dat hun beste handgeschreven wiskundige code het snelst zou zijn. Maar toen ze het maten, zagen ze dat hun aangepaste code slechts 37% van de maximale snelheid van de kaart bereikte. Daarna probeerden ze een standaard, oud hulpmiddel dat tien jaar geleden al bij de software van de kaart zat (genaamd cuBLAS). Verrassend genoeg draaide dit oude hulpmiddel op 64% van de maximale snelheid—bijna twee keer zo snel als hun aangepaste code! Ze leerden dat op oude hardware, de "saaie", kant-en-klare tools soms juist de supersnelle zijn. Dus besloten ze hun gegevens te vertalen naar een formaat dat het oude hulpmiddel kon begrijpen en lieten ze het oude hulpmiddel het zware werk doen.

2. De "Slow Motion" Fout
De AI heeft een speciaal onderdeel dat dingen onthoudt terwijl het ze leest, een beetje zoals een persoon een gesprek voert. Het team probeerde dit te versnellen door het gesprek in kleine stukjes op te delen. In het begin dachten ze dat deze nieuwe methode trager was. Ze gaven het bijna op! Maar toen ze de timing nauwkeurig bekeken, ontdekten ze dat één klein deel van hun code dezelfde wiskunde twee keer uitvoerde en de computer te vaak liet stoppen en weer starten. Zodra ze dat ene slechte deel hadden gerepareerd, werd de nieuwe "stukjes"-methode 2,8 keer sneller dan de oude manier. Het was een les dat je niet alleen naar het totaalplaatje kunt kijken; je moet elke individuele stap controleren om de bottleneck te vinden.

3. De "4-Bit" Valstrik
In de wereld van AI proberen mensen vaak het geheugen van het model te verkleinen door "4-bit" getallen te gebruiken in plaats van "8-bit" getallen, in de veronderstelling dat kleinere getallen betekenen dat de snelheid hoger is. Het team probeerde dit op de oude kaart. Hoewel 4-bit getallen de helft minder ruimte innemen, moest de kaart extra wiskunde uitvoeren om ze te "uitpakken", en de oude kaart is traag in die specifieke wiskunde. Het resultaat? De 4-bit versie was zelfs 12% trager dan de 8-bit versie. Dus bleven ze bij de grotere 8-bit getallen omdat, op deze specifieke oude kaart, groter ook echt sneller was.

4. De "Tie-Breaking" Regel
Wanneer de AI naar een afbeelding kijkt, moet hij uitzoeken waar elk stukje van de afbeelding zich bevindt. De onderzoekers probeerden hun eigen wiskunde te schrijven om te beslissen wat te doen wanneer twee stukjes precies op dezelfde lijn liggen (een "tie" of gelijkspel). Ze probeerden veel verschillende manieren om het op te lossen, maar elke keer was het resultaat iets anders dan het antwoord van de originele AI. Ze ontdekten dat de manier waarop de originele AI met gelijke gevallen omging een heel specifieke, kleine regel was die niet perfect gekopieerd kon worden met standaard wiskunde. De oplossing? Ze stopten met het proberen uit te vinden van het wiel en vroegen simpelweg de wiskundelibrari van de originele AI om het tie-breaking proces voor hen te doen. Dit zorgde ervoor dat hun versie exact hetzelfde was als het origineel.

5. Het "Lange Verhaal" Probleem
De grootste verrassing kwam toen ze de AI testten met lange vragen. Wanneer de vraag kort was (2.000 woorden), was de AI snel. Maar toen ze de vraag heel lang maakten (10.000 woorden), vertraagde de AI tot een kruipend tempo; hij werd 17 keer trager. Het bleek dat de manier waarop de AI terugkeek naar eerdere woorden rommelig en inefficiënt werd. Het team schreef dit deel opnieuw om gebruik te maken van hetzelfde "oude hulpmiddel" (cuBLAS) dat ze eerder gebruikten, maar ze arrangeerden de gegevens zodat ze perfect pasten in het geheugen dat de AI al gebruikte. Dit loste het probleem volledig op. Nu is de AI bijna net zo snel met een vraag van 10.000 woorden als met een korte vraag.

Het Eindresultaat
Door deze trucs te gebruiken, slaagde het team erin om een moderne, beeldlezende AI volledig te laten draaien op een videokaart uit 2011. Het hele systeem past in het geheugen van de kaart en kan een vraag over een afbeelding in slechts 1,7 seconden beantwoorden. Het kan zelfs zeer lange documenten en grote afbeeldingen aan zonder vast te lopen. De belangrijkste les van dit artikel is niet alleen dat ze een oude computer aan het werk kregen; het is dat ze leerden om te vertrouwen op metingen boven hun eigen intuïtie. Elke keer dat ze dachten het antwoord te weten (zoals "4-bit is sneller" of "onze aangepaste code is het best"), bewezen de metingen dat ze ongelijk hadden. Door naar de data te luisteren en de juiste tools te gebruiken, hebben ze een veertien jaar oud stuk hardware veranderd in een werkende, moderne AI-assistent.

Technische Samenvatting: Een Moderne Multimodale Assistent op een 6 GB 2011 GPU

Probleemstelling
Dit rapport behandelt de uitdaging om een huidige generatie multimodale assistent volledig on-device te draaien op de NVIDIA Tesla C2075 (Fermi-architectuur, 2011), een GPU met 6 GB geheugen, zonder tensor cores, en een compute capability (sm_20) die door moderne toolchains is verlaten (laatst ondersteund door CUDA 8.0). In tegenstelling tot een begeleidende studie [1] die een model van 35B parameters verwerkte door gewichten vanuit het host-RAM te streamen en decoding naar de CPU te offloaden, richt dit werk zich op een kleiner, modern model (MiniCPM-V-4.6) dat volledig binnen het devicegeheugen past. Het primaire doel is om de haalbare snelheid en correctheid van een all-GPU-inferentiepipeline voor een hybride multimodale architectuur op deze legacy-hardware te bepalen, waarbij de focus verschuift van geheugenbeperkingen naar throughput-optimalisatie en implementatiegetrouwheid.

Methodologie
De auteurs hebben MiniCPM-V-4.6 geïmplementeerd, bestaande uit een SigLIP2 vision encoder, een window-attention merger en een 0,8B-parameter hybride gated-delta-net taalbackbone. Het systeem werkt met 8-bit gekwantiseerde taalgewichten en FP32 vision-gewichten, waarbij het volledige model, de KV-cache en de scratch-buffers resident op de GPU blijven. De methodologie rust op drie kernzuilen:

Fase-gevalideerde Porting: Om de SigLIP2 vision tower naar handgeschreven sm_20 CUDA te porten, hebben de auteurs een "ground truth" vastgesteld door de referentie-implementatie te dwingen om op de host-CPU te draaien via een legacy code-pad (waarbij AVX-vereisten werden omzeild). Vervolgens hebben ze de tower fase voor fase geport (embeddings, 27 encoder-lagen, window-attention merger, projector), waarbij elke fase werd gevalideerd tegen de referentie-dump met een strikte overeenkomstdrempel ( $\sim 10^{-3}$ ).
Gemeten Optimalisatie boven Intuïtie: De performance van de engine werd gedreven door empirische meting in plaats van theoretische aannames. Belangrijke architecturale beslissingen werden gebaseerd op profiling in plaats van intuïtie:
- GEMM Efficiëntie: In plaats van te vertrouwen op handgeschreven GEMM-kernels, dekwantiseert het systeem 8-bit gewichten eenmalig naar FP32 en roept de vendor cuBLAS sgemm (CUDA 8.0) aan, wat 64% van de FP32-piekprestaties bereikte, bijna het dubbele van de 37% die door de beste handgeschreven tile werd behaald.
- Recursieve Lagen: De gated-delta-net lagen werden herschreven van een token-per-token scan naar een gechunkte intra-/inter-chunk delta-regel vorm. Eerdere pogingen waren trager vanwege een enkele inefficiënte forward-substitution kernel; het herstellen hiervan maakte de gechunkte aanpak 2,8× sneller dan de sequentiële recursie.
- Kwantisatie: In tegenstelling tot de aanname dat 4-bit gewichten de decode-snelheid zouden verhogen, ontdekten de auteurs dat de trage shift-instructies van Fermi (nodig voor nibble unpacking) de 4-bit decode 12% trager maakten dan 8-bit. Het systeem behield 8-bit gewichten voor decoding.
Attention Rewrites: De auteurs identificeerden een $O(N^2)$ bottleneck in de attention kernel die de throughput deed instorten bij lange contextlengtes. Ze herschreven zowel de bidirectionele attention van de vision tower als de causale attention van het taalmodel als per-head vendor-GEMM calls. Cruciaal was dat ze een "layout trick" gebruikten waarbij de GEMM de scores in de bestaande attention buffer schrijft (row-major versus column-major interpretatie), wat nul extra devicegeheugen vereist.

Belangrijkste Bijdragen en Resultaten

All-GPU Multimodale Inferentie: Het systeem draait MiniCPM-V-4.6 succesvol volledig op de C2075. De taalbackbone decodeert met 48,6 tokens/seconde (greedy).
Vision Tower Getrouwheid: De hand-geporteerde SigLIP2 tower komt overeen met de referentie-implementatie tot binnen $1,4 \times 10^{-5}$ per element. Een kritieke bevinding was dat index-arithmetiek met exacte rationale bindingen (bijv. $10/28 = 25/70$ ) implementatie-afhankelijk is; de auteurs concludeerden dat dergelijke operaties de referentie-operator moeten aanroepen in plaats van te worden geherimplementeerd om portabiliteit te garanderen.
Throughput Optimalisatie:
- Prefill: De naïeve attention kernel zorgde ervoor dat de prefill-throughput daalde van 114 tokens/s bij 2k context naar 21 tokens/s bij 10k. De GEMM-rewrite vlakte dit profiel af en behield 361 tokens/s bij 10k (een 17× reductie in prefill-tijd).
- Image Encoding: Dezelfde GEMM-rewrite verminderde de image encoding tijd met 6×, van 5,7s naar 0,93s per afbeelding.
End-to-End Performance: Een vraag met één afbeelding wordt beantwoord in 1,7 seconden. Een complexe multi-slice afbeelding (896×672) met tekst en vormen wordt verwerkt in ongeveer 7 seconden. Het systeem vindt correct een "needle" die op 60% diepte van een 10k-token document is geplaatst.

Betekenis en Claims
Het paper positioneert zichzelf als een engineering- en meetrapport in plaats van een claim van algoritmische nieuwheid. De betekenis ligt in het demonstreren dat moderne multimodale assistenten kunnen draaien op hardware die door het software-ecosysteem is verlaten, mits de implementatie rigoureus wordt gevalideerd tegen de ground truth.

De auteurs benadrukken een methodologische les: performance-plafonds en de locaties van bugs op legacy-hardware zijn onbetrouwbaar wanneer men erover redeneert, en alleen betrouwbaar wanneer ze worden gemeten tegen vendor-libraries, per-component timers en referentie-traces. Het werk zet vier zelfverzekerde intuïties onderuit (dat handgeschreven GEMM het plafond is, dat gechunkte scans trager zijn, dat 4-bit decode sneller is, en dat korte benchmarks representatief zijn voor long-context performance) door middel van empirische data. Daarnaast stelt het een regel vast voor het porten van index-arithmetiek met exacte bindingen: niet herimplementeren; roep de referentie-operator aan.

Het systeem dient als een proof of concept dat een "fase-gevalideerde" port, gecombineerd met vendor-geoptimaliseerde lineaire algebra calls en zorgvuldig geheugenbeheer, een 14 jaar oude GPU kan transformeren in een werkende, high-throughput multimodale inferentie-engine.

Meer zoals dit