# NVFP4 auf Bit-Ebene
> Alle anderen Posts sagen ‚4 Bit‘ und gehen weiter. Hier ist NVFP4 bis hinunter zu den vier Bits und zwei Skalierungsfaktoren, plus die zwei Blackwell-Instruktionen (cvt, mma), die es fliegen lassen.
Source: https://rfriedmann.de/de/blog/nvfp4-at-the-bit-level/ · English: https://rfriedmann.de/blog/nvfp4-at-the-bit-level/
Published: 2026-06-15 · Track: log · Level: Expert
Die übrigen Posts stützen sich auf „4 Bit“ und „NVFP4“, als wäre das offensichtlich. Ist
es nicht, jedenfalls nicht ganz. Hier steht das Format ausbuchstabiert: die vier Bits,
die zwei Skalierungsfaktoren, die sie retten, und die zwei Hardware-Instruktionen, die
das Ganze auf Blackwell schnell machen, das `cvt`, das dequantisiert, und das `mma`, das
die GEMM rechnet.
## Vier Bits: E2M1
Das Element von NVFP4 ist **E2M1**: ein Vorzeichenbit, zwei Exponentenbits, ein
Mantissenbit. Das ist alles. Diese vier Bits können genau acht Beträge kodieren.
E2M1: das gesamte Vokabular eines 4-Bit-Gewichts
[diagram omitted — see the page for the chart]
Vier Bits pro Zahl: ein Vorzeichen, zwei Exponent, eine Mantisse. Diese acht Beträge (plus die Spiegelung für negative Werte) sind alles, was ein einzelnes NVFP4-Gewicht sein kann. Der Dynamikumfang kommt von den Skalierungsfaktoren, nicht vom Wert.
Round-to-Nearest in diese Menge ist keine Schleife und kein Lookup, sondern eine
verzweigungsfreie Kaskade von Vergleichen gegen die Mittelpunkte. Acht Beträge, durch
das Vorzeichen zu sechzehn Werten gespiegelt, sind das gesamte Vokabular, in das jedes
Gewicht gequetscht wird.
## Zwei Skalierungsfaktoren retten vier Bits
Sechzehn Werte können natürlich keinen Layer voller Gewichte mit völlig
unterschiedlichen Beträgen darstellen. Der Dynamikumfang kommt nicht vom Wert, er kommt
von den **Skalierungsfaktoren**, und NVFP4 führt zwei davon.
Zwei Skalierungsfaktoren retten vier Bits
[diagram omitted — see the page for the chart]
Ein einzelner 4-Bit-Wert kann nicht den Wertebereich eines ganzen Layers abdecken, also führt NVFP4 zwei Skalierungsfaktoren: einen feinen in FP8 für je 16 Werte und einen groben in FP32 für den Tensor. MXFP4 nutzt stattdessen einen Zweierpotenz-Faktor pro 32 Werte, ohne Tensor-Faktor.
Ein feiner **FP8-Mikro-Skalierungsfaktor (E4M3)** deckt jede Gruppe von 16 Werten ab,
und ein einzelner grober **FP32-Tensor-Skalierungsfaktor** den ganzen Tensor. Ein
Gewicht zu rekonstruieren ist einfach `e2m1_value * micro_scale * tensor_scale`. Den
FP32-Faktor pro Tensor gibt es, damit die Faktoren pro Block in den Wertebereich von
E4M3 passen, und er wird in die Skalierungsfaktoren eingerechnet, statt zur GEMM-Zeit
als eigene Multiplikation pro Element angewendet zu werden. Das zweistufige Schema ist
es, das 4 Bit eine ausreißerreiche Gewichtsverteilung halten lässt, ohne sie
plattzudrücken. Was schiefgeht, wenn diese Faktoren am unteren Ende des Wertebereichs
von E4M3 ankommen, bei Aktivierungen und beim FP8-KV-Cache, steht in [Quantisierung lebt
in den Skalierungsfaktoren](/de/blog/quantization-lives-in-the-scales/).
MXFP4 ist der enge Verwandte: dieselben E2M1-Nibbles, aber der Faktor pro Gruppe ist
eine Zweierpotenz (UE8M0) über 32 Werte, und einen eigenen Tensor-Faktor gibt es nicht.
Beide Formate sind auf den Blackwell-Tensor-Cores gleichermaßen nativ: Die eine
MMA-Opcode-Art `mxf4nvf4` verarbeitet MXFP4 und NVFP4 gleichermaßen, unterschieden nur
durch den Typ des Skalierungsoperanden (UE8M0 oder UE4M3) und die
`scale_vec`-Granularität (pro 32 oder pro 16). Die Hardware toleriert NVFP4 nicht bloß,
sie liest es direkt, und das ist wichtig für den nächsten Teil.
## Die Hardware, die es fliegen lässt
Ein Format ist nur so gut wie das Silizium, das es liest, und hier verdient sich
Consumer-Blackwell seinen Lohn.
Auf dem **Decode**-Pfad nimmt eine einzige PTX-Instruktion, `cvt.rn.f16x2.e2m1x2`, ein
Byte (zwei gepackte FP4-Werte) und erzeugt in einem Schritt zwei FP16-Zahlen, anstelle
von rund einem Dutzend Software-Operationen. Die Dequantisierung, die einen naiven
Kernel dominieren würde, schrumpft auf eine einzige `cvt`-Instruktion, statt ganz zu
verschwinden.
Auf dem **Prefill**-Pfad läuft die Matrixmultiplikation auf der Tensor-Core-Instruktion
`mma.sync.aligned.m16n8k64.row.col.kind::mxf4nvf4.block_scale.scale_vec::4X.f32.e2m1.e2m1.f32.ue4m3`:
64 FP4-Elemente pro Schritt, wobei der Block-Skalierungsfaktor pro 16 (die Operanden
`scale_vec::4X` und `ue4m3`) *in* der Hardware angewendet wird. Diese eine Instruktion
ist das Fundament, auf dem die gesamte
[NVFP4-GEMM](/de/blog/optimizing-kernels-consumer-blackwell/) gebaut ist.
## Packen und Herkunft
Zwei FP4-Werte teilen sich ein Byte (unteres Nibble gerader Index, oberes ungerader).
Die Gewichte kommen meist schon in dieser Form an, exportiert von NVIDIAs Model
Optimizer oder llm-compressor, und imp registriert sie unverändert, ohne neue
Quantisierung. Oder imp erzeugt sie selbst und wandelt GGUF-Gewichte beim Laden in NVFP4
um, um den [Decode-Cache](/de/blog/gguf-decode-beats-llama-cpp/) zu füttern.
Wenn die anderen Posts also sagen, ein Modell „läuft in 4 Bit“, ist das die Maschinerie:
acht Beträge, zwei Skalierungsfaktoren und eine Dequantisierung in einer Instruktion,
die es nur gibt, weil die 5090 echte FP4-Tensor-Cores hat. Das ist [ein Hauptgrund,
warum die 5090 bei NVFP4-Inference schnell
ist](/de/blog/what-the-5090-lacks-vs-datacenter/), neben Speicherbandbreite,
Decode-Cache und den Attention-Kerneln.