💻 computer science

Hawkeye: Reproducing GPU-Level Non-Determinism

Dit paper introduceert Hawkeye, een systeem dat het mogelijk maakt om matrixvermenigvuldigingen van NVIDIA GPU's met volledige precisie op een CPU te reproduceren door systematisch rekening te houden met niet-deterministische factoren zoals africhting en subnormale getallen, waardoor efficiënte en betrouwbare auditing van machine learning-modellen wordt mogelijk gemaakt.

Oorspronkelijke auteurs: Erez Badash, Dan Boneh, Ilan Komargodski, Megha Srivastava

Gepubliceerd 2026-03-24

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Erez Badash, Dan Boneh, Ilan Komargodski, Megha Srivastava

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

🦅 Wat is Hawkeye? (De "Super-Oog")

Stel je voor dat je een enorme, ingewikkelde taak laat uitvoeren door een superkrachtige robot (een GPU, zoals die van NVIDIA) in de cloud. Jij bent de klant en je wilt zeker weten dat de robot de taak écht goed heeft gedaan, zonder te trappen of te valsspelen.

Het probleem is echter: robots zijn soms niet 100% voorspelbaar.

Als je dezelfde taak twee keer geeft aan twee verschillende robots (of zelfs dezelfde robot op een ander moment), kunnen ze soms heel kleine, onzichtbare verschillen in het antwoord geven. Dit komt doordat de robot gebruikmaakt van speciale, snelle trucs (zoals de "Tensor Cores") om wiskundige berekeningen te versnellen. Deze trucs zijn zo snel dat ze soms kleine afrondingsfoutjes maken of in een andere volgorde rekenen dan een gewone computer.

Hawkeye is een nieuw systeem dat als een "super-oog" fungeert. Het kan precies nabootsen hoe die snelle robot denkt en rekent. Hierdoor kun je op een gewone computer (een CPU) exact hetzelfde resultaat krijgen als de robot, tot op het laatste cijfer.

🧩 Het Probleem: Waarom is dit lastig?

Om dit te begrijpen, moeten we kijken naar hoe computers rekenen.

Stel je voor dat je een enorme stapel geld moet tellen.

De gewone manier (CPU): Je telt elke munt één voor één, heel zorgvuldig. Dit is traag, maar altijd hetzelfde resultaat.
De snelle manier (GPU Tensor Cores): Je gooit 16 munten tegelijk in een machine die ze in een flits telt. Dit is razendsnel, maar de machine heeft een eigen manier van werken.

Het probleem is dat de snelle machine soms:

Afrondt op een andere manier: Als er een halve cent overblijft, rondt de ene machine naar boven af, de andere naar beneden.
Verwaarloosbare details: Als een getal heel klein is (zoals een stofje), gooit de snelle machine het soms weg, terwijl de gewone computer het nog wel ziet.
In een andere volgorde telt: Als je $A + B + C$ doet, maakt het voor de snelle machine uit of je eerst $A+B$ doet en dan $+C$ , of eerst $B+C$ en dan $+A$ . Bij heel kleine getallen leidt dit tot verschillende eindresultaten.

In het verleden was dit een nachtmerrie voor controleurs. Als je de uitkomst van de robot vergelijkt met je eigen berekening, en ze verschillen ook maar één klein beetje, wist je niet of de robot vals speelde of dat het gewoon een "rekenverschil" was door de snelle trucs.

🔍 Hoe werkt Hawkeye? (De Detectivewerk)

De auteurs van het paper hebben Hawkeye gebouwd als een detective die de geheimen van de snelle robot ontrafelt. Ze hebben geen magische formule gebruikt, maar een reeks slimme tests uitgevoerd.

Stel je voor dat je een slot wilt kraken, maar je mag het niet openbreken. Je moet het slot bestuderen door er zachtjes op te tikken en te kijken hoe het reageert.

Hawkeye doet precies dit met de rekenmachine van de GPU:

De "Nul-test": Ze voerden berekeningen uit waarbij de uitkomst theoretisch nul zou moeten zijn. Maar ze voegden heel kleine, onzichtbare getallen toe. Als de uitkomst niet precies nul was, wisten ze: "Ah, de machine gooit die kleine getallen weg!"
De "Orde-test": Ze veranderden de volgorde van de getallen. Als het eindresultaat veranderde, wisten ze precies in welke volgorde de machine de getallen bij elkaar optelde.
De "Afronding-test": Ze gaven de machine getallen die precies halverwege lagen tussen twee mogelijke antwoorden. Kijkt de machine naar boven of naar beneden? Hawkeye ontdekte dat de machine vaak gewoon "afkapt" (naar nul toe afrondt) in plaats van naar het dichtstbijzijnde getal te kijken.

Door duizenden van deze tests te doen op verschillende soorten GPUs (zoals de Ampere, Hopper en Lovelace modellen), hebben ze een perfecte blauwdruk gemaakt van hoe de machine denkt.

🛠️ Het Resultaat: Een "Tweeling" op de Gewone Computer

Zodra Hawkeye weet hoe de snelle robot denkt, kan het die logica nabootsen op een gewone computer.

Vroeger: Je had een gewone computer nodig die de hele taak opnieuw deed, maar dan heel traag en vaak met een ander antwoord.
Nu met Hawkeye: Je hebt een "spiegel" op je gewone computer. Deze spiegel denkt precies zoals de snelle robot.

Als je nu een berekening doet op de snelle robot en dezelfde berekening op je Hawkeye-spiegel, en de uitkomsten zijn niet hetzelfde, dan weet je 100% zeker dat er iets mis is gegaan. Misschien heeft de robot de taak niet gedaan, of heeft hij een andere, kleinere versie van het model gebruikt om tijd te besparen.

🌍 Waarom is dit belangrijk?

Dit is een revolutie voor vertrouwen in AI.

Vandaag de dag gebruiken veel bedrijven AI-modellen die ze niet zelf hebben gebouwd, maar die ze huren van grote cloudbedrijven. Ze moeten die bedrijven vertrouwen. Met Hawkeye hoeven ze niet meer blind te vertrouwen. Ze kunnen zeggen: "Laat me zien dat je het echt hebt gedaan. Ik heb een Hawkeye-simulatie die precies jouw antwoord moet geven. Als het niet klopt, heb je valsspeeld."

Het maakt AI controleerbaar en eerlijk, zonder dat de snelheid van de snelle robots verloren gaat. Het is alsof je een onzichtbare, perfecte controleur hebt die meekijkt met elke berekening die een robot maakt.

Kortom: Hawkeye is de sleutel om de "magie" van snelle AI-computers te doorgronden, zodat we ze kunnen vertrouwen, zelfs als we ze niet zelf in de hand hebben.

Probleemstelling

Moderne machine learning (ML), zowel voor training als inferentie, is afhankelijk van zware rekenkracht die vaak wordt uitgevoerd op gespecialiseerde hardware zoals NVIDIA GPU's met Tensor Cores. Een groot probleem bij het verifiëren van deze berekeningen (bijvoorbeeld door een derde partij om te controleren of een dienstverlener de taak correct uitvoert) is niet-determinisme.

Hoewel wiskundige bewerkingen deterministisch zijn, leiden de specifieke implementaties van floating-point-aritmetica op GPU's tot variaties in uitkomsten. Dit komt door:

Rounding strategies: Hoe afronding plaatsvindt bij het verlies van precisiebits.
Subnormale getallen: Hoe getallen dicht bij nul worden behandeld.
Volgorde van accumulatie: Omdat floating-point optelling niet associatief is ( $(a+b)+c \neq a+(b+c)$ ), leidt een andere volgorde van optellen tot verschillende resultaten.

Dit betekent dat een auditor die dezelfde berekening op een CPU probeert na te bootsen, vaak een ander bit-voor-bit resultaat krijgt dan de GPU, zelfs als beide correct werken. Bestaande oplossingen voor verifieerbaar ML zijn vaak te traag, introduceren precisieverlies, of vertrouwen op heuristieken die geen formele garanties bieden.

Methodologie: Hawkeye

Hawkeye is een systeem ontworpen om de exacte bit-voor-bit uitkomst van matrixvermenigvuldigingen (de kernbewerking van ML) op NVIDIA GPU's te reproduceren op een CPU, zonder precisieverlies. De kern van de methodologie is een systematische reeks gerichte tests om de interne numerieke logica van de Tensor Coers te "reverse-engineeren".

De aanpak bestaat uit de volgende stappen:

Custom CUDA Kernels: Het auteurs schrijven aangepaste CUDA-kernels die direct de hardware-instructies (via PTX/SASS assembly) aanroepen om specifieke eigenschappen te isoleren.
Gerichte Tests: Er worden tests uitgevoerd op $16 \times 16$ $16 \times 16$ tegels (tiles) van matrices om de volgende aspecten te karakteriseren:
- Som-afhankelijkheid en volgorde: Het bepalen van de exacte volgorde waarin de 16 deelsommen worden opgeteld (bijv. in twee fasen of één fase).
- Interne precisie detectie: Het vaststellen hoeveel bits (mantisse) de interne accumulator gebruikt (vaak hoger dan de invoerprecisie).
- Afrondingsmodus detectie: Het bepalen of de hardware afrondt naar het dichtstbijzijnde getal, naar nul, of naar oneindig, specifiek tijdens verschuifoperaties (alignment) en bij de finale conversie.
- Normalisatie-tijdstip: Het onderzoeken of tussenresultaten direct worden genormaliseerd of dat dit wordt uitgesteld tot na de accumulatie.
- Subnormaal gedrag: Hoe de hardware omgaat met producten van subnormale getallen.
Software Simulator: De resultaten van deze tests worden gecodeerd in een software-simulator die de gedetecteerde semantiek exact nabootst.

Belangrijkste Bijdragen en Technische Bevindingen

Het paper levert een diepgaand inzicht in de interne werking van Tensor Cores op verschillende architecturen (Ampere, Hopper, Lovelace) en precisies (FP16, BF16, FP8).

1. Gedetailleerde Pipeline voor Ampere (FP16):

Accumulatiestructuur: De sommatie gebeurt in twee fasen: eerst worden de eerste 8 producten opgeteld met de initiële accumulator, en vervolgens wordt dit resultaat opgeteld met de laatste 8 producten.
Interne precisie: De accumulator gebruikt een interne precisie van 24 bits (inclusief de impliciete leidende bit), wat overeenkomt met FP32.
Afronding: Tijdens het uitlijnen van exponenten (shift-operaties) wordt afgerond naar nul (truncatie), niet naar het dichtstbijzijnde even getal.
Normalisatie: Tussenproducten worden niet direct genormaliseerd voordat ze naar de accumulator worden gestuurd. Dit zorgt ervoor dat kleine waarden niet verloren gaan door te grote exponentverschillen.
Subnormale getallen: Producten van subnormale getallen worden niet opnieuw genormaliseerd; de verminderde precisie wordt direct doorgegeven.

2. Verschillen met Hopper Architectuur:

De Hopper-architectuur gebruikt een enkele fase voor accumulatie: alle 16 producten worden samen met de initiële accumulator in één stap opgeteld.
De interne mantisse is hier 25 bits (in plaats van 24 bij Ampere).
De afrondingsmodus blijft "rond naar nul".

3. BF16 en FP8:

Voor BF16 worden dezelfde strategieën gebruikt als bij FP16 op Ampere, maar met extra tests voor overloop (overflow) en subnormale situaties die specifiek zijn voor het brede exponentbereik van BF16.
Het systeem toont aan dat intermediaire waarden tijdelijk buiten het FP32-bereik kunnen vallen, maar dat de finale uitkomst correct wordt gemapt naar FP32 (met saturation naar oneindig indien nodig).

Resultaten

100% Succesratio: Hawkeye slaagt erin om de exacte bit-voor-bit uitkomst te reproduceren voor grote matrixvermenigvuldigingen ( $4096 \times 4096$ ) op CPU's, ongeacht de gebruikte GPU-architectuur of precisie (FP16, BF16, FP8).
Validatie: De simulatoren zijn getest tegen honderdduizenden willekeurig gegenereerde $16 \times 16$ tegels en toonden geen enkele afwijking ten opzichte van de hardware-uitvoer.
Efficiëntie: Hoewel de CPU-uitvoering trager is dan de GPU, is dit acceptabel voor audit-doeleinden waarbij een enkele reproduceerbare uitvoering volstaat om de integriteit van een dienstverlener te verifiëren.

Betekenis en Toekomstperspectief

De betekenis van Hawkeye ligt in het mogelijk maken van verifieerbaar Machine Learning:

Betrouwbaarheid: Het lost het probleem van niet-determinisme op door een "oracle" (een referentie-uitvoering op CPU) te bieden waartegen GPU-resultaten kunnen worden vergeleken. Afwijkingen duiden nu zeker op fouten of kwaadaardig gedrag (zoals het gebruik van een kleiner model om kosten te besparen), en niet op hardware-variabiliteit.
Onafhankelijke Audit: Het stelt derden in staat om ML-modellen te auditen zonder de originele GPU-kernels te hoeven wijzigen of de prestaties van de dienstverlener te vertragen.
Fundamenteel Inzicht: Het paper biedt het eerste gedetailleerde, empirische inzicht in de numerieke pipeline van moderne Tensor Cores, wat essentieel is voor het bouwen van robuuste cryptografische bewijssystemen voor ML.

Toekomstig werk richt zich op het uitbreiden van deze methoden naar andere hardwareleveranciers, het integreren van hogere niveau-bewerkingen (zoals convoluties en attention-mechanismen), en het oplossen van schaalbaarheidsuitdagingen in gedistribueerde omgevingen.