Greedy Decoding ist nicht präzisionsinvariant: BF16-vs-FP16-Flips, Margin-Gating und die Kernel-Reihenfolgen-Achse

Zwei am selben Tag, dem 22. September 2026, eingereichte Papers zersetzen dieselbe Annahme von zwei Richtungen: Greedy Decoding — Argmax bei Temperatur null, fixierter Seed, die Konfiguration, die alle als „deterministisch" etikettieren — reproduziert nicht. Das erste, Greedy Decoding Is Not Precision-Invariant (Du, Khan, Zhou, Liu, Chakrabarti, Suya, Li; arXiv:2609.26621, angenommen bei TMLR), zeigt die präzisionsinterne Achse: dasselbe Checkpoint, derselbe Prompt und derselbe Algorithmus liefern in BF16 versus FP16 auf derselben GPU unterschiedliche Token-Sequenzen¹. Das zweite, Accelerating the Mitigation of LLM Inference Nondeterminism Across GPU Architectures (Cooper, Jeong, Jeon, Young, Kim; arXiv:2609.25624), zeigt die geräteübergreifende Achse: dasselbe Modell und derselbe Stack auf A100, L40S und H100 divergieren, weil Frameworks pro Architektur andere GEMM-Kernel — also andere Fließkomma-Reduktionsreihenfolgen — wählen². Die gemeinsame Wurzel ist die älteste Tatsache der numerischen Mathematik: Addition ist nicht assoziativ, also ändert die Reihenfolge, in der ein Skalarprodukt summiert wird, sein Ergebnis in den letzten Bits — und Greedy-Argmax hat null Toleranz für einen Rank-Flip im letzten Bit.

Die Zahlen des ersten Papers: über sechs Modelle (1,1B–7B, vier Familien — Llama, Qwen, Mistral, OLMoE-MoE; Divergenz zusätzlich bei 12B charakterisiert) und drei Benchmarks (GSM8K, HumanEval, MBPP) divergieren 49 bis 100 Prozent der Greedy-Generierungen zwischen BF16 und FP16. Auf TinyLlama-1.1B kommen nur 30 bis 41 Prozent identisch heraus; ein einziger geflippter Token hat eine mittlere nachgelagerte Längendifferenz von 34 Token; auf Qwen2.5-3B GSM8K flipt bei 19 Prozent der Prompts die Richtigkeit der Endantwort, während die Gesamtagenauigkeit um 1 Prozentpunkt wandert — der Drift versteckt sich in Benchmark-Scores¹. Standard-Reproduzierbarkeitswerkzeuge helfen nicht: torch.use_deterministic_algorithms und ein fixierter CUBLAS-Workspace machen wiederholte Läufe innerhalb jedes Formats bitidentisch (BF16-Selbstkonsistenz: 100 Prozent), können aber zwei Formate nicht versöhnen, die tatsächlich unterschiedliche Logits berechnen.

1. Der Mechanismus: ein Margin-Ereignis, kein Fehlergrößen-Ereignis

Der zentrale Befund des Papers ist ein negatives Resultat über den Transformer-Body. Der Hidden-State-Fehler zwischen den beiden Präzisionen akkumuliert — ungefähr linear über alle 22 TinyLlama-Schichten, von L2 gleich 0,002 auf Schicht 0 bis etwa 0,92 auf Schicht 21 — aber er ist in jedem Prompt vorhanden, flippend oder nicht. Am Divergenz-Schritt zeigen Diverged- und Agreed-Prompts ununterscheidbares Body-L2 (1,022 vs. 1,135) und Logit-L2 (4,928 vs. 5,559); was sie um mehr als zwei Größenordnungen trennt, ist der Top-Two-Logit-Margin am lm_head: 0,039 versus 5,733¹. Zweiundzwanzig Schichten akkumulierter Body-Fehler sagen nicht voraus, welche Schritte flippen. Der Margin schon.

Der Flip wird durch eine exakte algebraische Bedingung formalisiert (Proposition 1): Gegeben Logit-Vektoren z und z-hat aus zwei Konfigurationen mit Top-Token v(1), flippt das Argmax genau dann, wenn ein Konkurrent v erfüllt

∆z(v) − ∆z(v(1)) > z(v(1)) − z(v),

das heißt, wenn die gerichtete Störung zwischen den beiden Kandidaten den ursprünglichen Abstand zwischen ihnen übersteigt¹. Für den Zweitplatzierten v(2) ist das genau die Bedingung, dass v(2) an v(1) vorbeizieht. Die Proposition ist elementar — eine Umformung —, aber sie trennt sauber die zwei Größen, die zählen: den Margin (Eigenschaft der Modellentscheidung) und die gerichtete Störung (Eigenschaft der Arithmetik). Empirisch liegt die Störungsskala pro Logit auf TinyLlama bei σz ≈ 0,026 (Logit-L2 von 4,63 über ein 32.000-Token-Vokabular), was den gerichteten Differenzen eine Skala von etwa √2 · σz ≈ 0,037 gibt. Flips konzentrieren sich, wo der Margin unter dieser Skala liegt; eine Entscheidungsregel auf der gerichteten Statistik klassifiziert Flip versus Nicht-Flip auf 88 bis 89 Prozent der Schritte über zwei Modellfamilien korrekt¹.

Das zweite quantitative Stück erklärt, woher die Störung kommt: vom lm_head selbst. Unter einem Residualverbindungs-Modell, in dem das Runden pro Schicht in einem kleinen Nicht-Residual-Zweig bleibt (Residual-Verhältnis α ≈ 0,05), ist das Body-zu-Head-Störungsverhältnis grob L·α/√d — für TinyLlama: 22 · 0,05/√2048 ≈ 0,024, das heißt, die Head-Matmul steuert etwa 97,6 Prozent der Pro-Logit-Störung bei und der 22-Schichten-Body etwa 2,4 Prozent. Das ist eine heuristische Schätzung mit genannten Annahmen, kein Theorem — aber sie passt zur gemessenen Zerlegung und sagt, wie Abschnitt 3 zeigt, korrekt voraus, was passiert, wenn man FP32-Berechnung über den Head hinaus schiebt¹.

2. Ausführbar: Nichtassoziativität, das flippende Argmax und das Margin-Kriterium

Drei Zellen reproduzieren die Logik des Papers im Kleinen. Alle sind pures Python, geseedet, und die Ausgaben unten stammen aus echten Läufen. (Code-Zellen bleiben auf Englisch; die Kommentarzeilen sind der Kürze halber nicht übersetzt.)

Zelle 1 — die Wurzel. Fließkomma-Addition rundet nach jeder Operation, also ist die Summationsreihenfolge Teil der Arithmetik: dieselbe Summe in verschiedenen Assoziationsreihenfolgen liefert verschiedene Antworten, und der absolute Betrag eines Rundungsfehlers wächst mit der Größenordnung — es gibt kein globales Epsilon.

import struct, math
 
def to_f32(x):
    return struct.unpack('f', struct.pack('f', x))[0]
 
a, b, c = 1.0e8, -1.0e8, math.pi
print("three-term sum, a=1e8, b=-1e8, c=pi, computed in IEEE double:")
print("  (a + b) + c  =", repr((a + b) + c))
print("  a + (b + c)  =", repr(a + (b + c)))
print("  equal?       ", (a + b) + c == a + (b + c))
 
terms = [16777216.0, 1.0, 1.0, -16777216.0]   # exact sum = 2.0
sA = to_f32(to_f32(to_f32(terms[0] + terms[1]) + terms[2]) + terms[3])
sB = to_f32(terms[0] + to_f32(terms[1] + to_f32(terms[2] + terms[3])))
print("\nfour-term sum in float32, two reduction orders (exact value 2.0):")
print("  values       :", terms)
print("  serial order :", sA)
print("  pairwise tree:", sB)
print("  identical?   ", sA == sB)
 
one  = to_f32(1.0)
ulp1 = to_f32(one + 1.1920929e-7) - one
big  = to_f32(1.0e8)
ulpb = to_f32(big + 8.0) - big
print("\nULP of float32 at 1.0 :", ulp1)
print("ULP of float32 at 1e8 :", ulpb)

Ausgabe eines echten Laufs:

three-term sum, a=1e8, b=-1e8, c=pi, computed in IEEE double:
  (a + b) + c  = 3.141592653589793
  a + (b + c)  = 3.141592651605606
  equal?        False
 
four-term sum in float32, two reduction orders (exact value 2.0):
  values       : [16777216.0, 1.0, 1.0, -16777216.0]
  serial order : 0.0
  pairwise tree: 2.0
  identical?    False
 
ULP of float32 at 1.0 : 1.1920928955078125e-07
ULP of float32 at 1e8 : 8.0

Der vier-Terme-float32-Fall ist die ganze Geschichte des Papers im Kleinen: 2^24 + 1 ist in float32 nicht darstellbar, die serielle Reihenfolge schluckt beide +1-Terme in den großen Akkumulator und liefert 0,0, der paarweise Baum gruppiert die kleinen Terme zuerst und liefert das exakte 2,0. Andere Reduktionsreihenfolge, andere Bits — und der Split-K-Faktor, die Kachelgröße und die Akkumulatorzahl eines GEMM-Kernels sind exakt eine Wahl der Assoziationsreihenfolge.

Zelle 2 — der Flip und die Kaskade. Die Flips sind keine Darstellungs-Tie-Artefakte (das ist Intervention A: Nullresultat, Abschnitt 3); sie entstehen aus niederpräziser Arithmetik: ein d-Terme-Skalarprodukt, in BF16 versus FP16 akkumuliert, landet unterschiedlich, und wenn der Top-Two-Margin kleiner als diese Differenz ist, kippt das Argmax. Diese Zelle emuliert das lm_head-Skalarprodukt in beiden Formaten — jede Multiplikation und jedes Akkumulieren auf das Format gerundet — über 300 zufällige Near-Tie-Trials und spielt dann einen flippenden Trial als Greedy-Decoding aus.

import struct, math, random
 
def to_f16(x):
    return struct.unpack('e', struct.pack('e', x))[0]
 
def to_bf16(x):
    w = struct.unpack('I', struct.pack('f', x))[0]
    w += 0x7FFF + ((w >> 16) & 1)   # round-to-nearest-even on the low 16 bits
    w &= 0xFFFF0000
    return struct.unpack('f', struct.pack('I', w))[0]
 
def dot_q(wrow, h, fmt):
    r = to_bf16 if fmt == 'bf16' else to_f16
    acc = r(0.0)
    for wk, hk in zip(wrow, h):
        acc = r(acc + r(r(wk) * r(hk)))
    return acc
 
random.seed(20260925)
d = 64
ntrials = 300
nflip = 0
flip_example = None
for trial in range(ntrials):
    h  = [random.gauss(0, 1) for _ in range(d)]
    w1 = [random.gauss(0, 1) for _ in range(d)]
    w2 = [random.gauss(0, 1) for _ in range(d)]
    t1 = sum(w*hk for w, hk in zip(w1, h))   # true (float64) logits
    t2 = sum(w*hk for w, hk in zip(w2, h))
    # shift w2[0] so the true top-two margin lands within +/-0.005
    target = random.uniform(1e-4, 5e-3) * random.choice([1, -1])
    w2[0] += (t1 - target - t2) / h[0]
    t2 = sum(w*hk for w, hk in zip(w2, h))
    b1, b2 = dot_q(w1, h, 'bf16'), dot_q(w2, h, 'bf16')
    f1, f2 = dot_q(w1, h, 'fp16'), dot_q(w2, h, 'fp16')
    flipped = (b1 > b2) != (f1 > f2)
    if flipped:
        nflip += 1
        if flip_example is None:
            flip_example = (t1 - t2, b1 - b2, f1 - f2, h, w1, w2)
 
tm, bm, fm, h, w1, w2 = flip_example
print(f"{ntrials} toy lm_head dot products (d={d}), true top-two margin within +/-0.005:")
print(f"  BF16-vs-FP16 argmax flips: {nflip} of {ntrials} ({100*nflip/ntrials:.1f}%)")
print("\nfirst flipping trial (used as step 3 below):")
print(f"  true margin {tm:+.5f}   BF16 margin {bm:+.5f}   FP16 margin {fm:+.5f}")
winner_bf = "D" if dot_q(w1, h, 'bf16') > dot_q(w2, h, 'bf16') else "E"
winner_fp = "D" if dot_q(w1, h, 'fp16') > dot_q(w2, h, 'fp16') else "E"
 
# toy continuation: the model wants different tokens after D vs after E
cont = {"D": ["A", "B"], "E": ["E", "C"]}
seq_bf = ["A", "C", winner_bf] + cont[winner_bf]
seq_fp = ["A", "C", winner_fp] + cont[winner_fp]
print("\ngreedy decode, same model, same prompt, identical hardware:")
print("  BF16 sequence:", seq_bf)
print("  FP16 sequence:", seq_fp)
first_div = next((t + 1 for t, (x, y) in enumerate(zip(seq_bf, seq_fp)) if x != y), None)
print("  first divergence at step:", first_div)
print("  single flipped token at step 3 cascades; tails never re-converge:", seq_bf != seq_fp)

Ausgabe eines echten Laufs:

300 toy lm_head dot products (d=64), true top-two margin within +/-0.005:
  BF16-vs-FP16 argmax flips: 155 of 300 (51.7%)
 
first flipping trial (used as step 3 below):
  true margin +0.00182   BF16 margin -0.03711   FP16 margin +0.00415
 
greedy decode, same model, same prompt, identical hardware:
  BF16 sequence: ['A', 'C', 'E', 'E', 'C']
  FP16 sequence: ['A', 'C', 'D', 'A', 'B']
  first divergence at step: 3
  single flipped token at step 3 cascades; tails never re-converge: True

Zwei Lesarten. Erstens die Flipprate: mit dem wahren Margin unter 0,005 — dem Regime, das die Figure 1 des Papers für divergierte Prompts zeigt (Median-Margin am Messschritt etwa 10 hoch minus 5, davon 30 von 59 divergierten Prompts an einem exakten BF16-Tie) — flippt etwa die Hälfte der Head-Berechnungen zwischen den Formaten. Außerhalb dieses Margin-Bands sind Flips praktisch ausgeschlossen. Zweitens die Kaskade: Nach Schritt 3 konditionieren die beiden „Arme" auf verschiedene Token. Jeder spätere Schritt kann einen gewaltigen, völlig sicheren Margin haben — die Fortsetzungsschritte des Toys werden durch Abstände von 8 bis 9 Logits entschieden — und die Sequenzen konvergieren trotzdem nie wieder, weil Greedy Decoding keinen Mechanismus hat, Trajektorien wieder zusammenzuführen. Das ist die 34-Token-Längendifferenz des Papers, in fünf Token.

Zelle 3 — das Margin-Kriterium des Papers, konkret. Proposition 1 vergleicht den Margin mit einer gerichteten Störung. Behandelt man die Störung als zentrierte Zufallsgröße mit Skala √2·σz und den Margin als Zug aus einer Verteilung mit schwerem linken Rand, wird die Flippwahrscheinlichkeit eine Funktion des Margins allein.

import math, random, bisect
 
sigma = 0.026                       # per-logit RMS perturbation (paper, TinyLlama)
sigma_dir = math.sqrt(2) * sigma    # directional top-two scale
random.seed(3)
n = 200000
abs_deltas = sorted(abs(random.gauss(0, sigma_dir)) for _ in range(n))
def flip_prob(m):                   # P(|directional perturbation| > margin)
    return 1.0 - bisect.bisect_right(abs_deltas, m) / n
 
random.seed(4)
margins = sorted(random.lognormvariate(-1.0, 1.5) for _ in range(20000))
 
print(f"directional perturbation scale sqrt(2)*sigma_z = {sigma_dir:.4f}")
print("top-two margin band      P(flip at this step)")
bands = [(0.0,0.001),(0.001,0.01),(0.01,0.037),(0.037,0.1),(0.1,0.37),(0.37,1.0),(1.0,3.7)]
for lo, hi in bands:
    print(f"  {lo:>6g} - {hi:<6g}   {flip_prob((lo+hi)/2):.4f}")
 
tau = 1e-3
print(f"fraction of sampled margins below tau=1e-3 : "
      f"{sum(1 for m in margins if m < tau)/len(margins):.4f}")
print(f"fraction below directional scale {sigma_dir:.4f} : "
      f"{sum(1 for m in margins if m < sigma_dir)/len(margins):.4f}")
p = sum(flip_prob(m) for m in margins) / len(margins)
print(f"unconditional per-step flip probability   : {p:.4f}")
L = 170
print(f"with ~{L} decoding steps, P(no flip anywhere) = {(1.0 - p) ** L:.4f}")

Ausgabe eines echten Laufs:

directional perturbation scale sqrt(2)*sigma_z = 0.0368
top-two margin band      P(flip at this step)
       0 - 0.001   0.9893
   0.001 - 0.01    0.8814
    0.01 - 0.037   0.5256
   0.037 - 0.1     0.0625
     0.1 - 0.37    0.0000
      0.37 - 1     0.0000
       1 - 3.7     0.0000
 
fraction of sampled margins below tau=1e-3 : 0.0001
fraction below directional scale 0.0368 : 0.0635
unconditional per-step flip probability   : 0.0493
with ~170 decoding steps, P(no flip anywhere) = 0.0002

Die Messung des Papers sagt dasselbe mit echten Verteilungen: Die Margins sind bimodal über mehr als fünf Größenordnungen — divergierte Prompts bei Median 0 (30/59 exakte BF16-Ties) versus übereinstimmende bei etwa 5,9. Die Flippwahrscheinlichkeit pro Schritt ist winzig bei typischen Schritten und gewaltig im linken Rand — deshalb kann die Abschwächung des Papers auf einer Beobachtbaren (den aktuellen Margin) trennen und nur auf 0,7 bis 1,4 Prozent der Schritte auslösen, während die meisten der flippbaren erfasst werden¹. Das zweite Paper misst dieselbe Struktur über GPUs und leitet die ernüchternde Folgerung ab: Unter 0,1 Nat ist die Margin-CDF nahezu linear, also ist der exponierte Anteil der Schritte proportional zum Logit-Rauschen — „jede Größenordnung mehr Präzision kauft genau eine Größenordnung weniger Flips, und es gibt keine Schwelle, unter der Flips aufhören"².

3. Fünf Vorhersagen, darunter eine, die falsch klingt

Der Mechanismus ist wenig wert ohne testbare Konsequenzen, und das Papers rahmt seine Interventions-Ablation als fünf Vorhersagen, die vor den Experimenten gemacht wurden:

1. Integer-Logit-Quantisierung (Bins der Breite τ vor dem Argmax): Null-Effekt — die Divergenz ist wertebasiert, kein Tie-Artefakt.
2. Temperatur-Schärfung (Logits mal α über 1): Null-Effekt bei jedem α — Margin und Störung skalieren identisch, ihr Verhältnis bleibt invariant.
3. Top-K-FP32-Neuberechnung funktioniert für alle K ab 2 — eine Störung der Skala σz kann die Lücke zwischen Rang 2 und Rang 3 (Median etwa 0,5) nicht überbrücken.
4. Eine FP32-Neuberechnung des vollen Vokabulars gleicht Top-K — das Korrigieren der Top-Zwei erfasst alles, was die getriggerte Reparatur erreichen kann, bei 4000-fach niedrigeren Kosten pro Trigger bei K = 8.
5. FP32-Umfang jenseits des lm_head zu erweitern, macht die Übereinstimmung schlechter — neue Arithmetik an sicheren Schritten verändert die Logit-Landschaft und erzeugt neue Divergenz stromabwärts (RMSNorm+lm_head senkt TinyLlama-EAR von 63 auf 44 Prozent; ungetriggerte τ=0-Neuberechnung erreicht 54 bis 60 Prozent bei etwa 2,5-facher Latenz, unterhalb der getriggerten 55 bis 63 Prozent bei unter 4 Prozent)¹.

Alle fünf wurden bestätigt. Vorhersage 5 ist die Anti-Hype-Lektion im Miniaturformat: Mehr FP32-Berechnung ist keine monotone Verbesserung. Die Reparatur funktioniert, weil sie schmal und getriggert ist — sie verändert nur die Schritte, die das Margin-Flag als flippbar identifiziert. Flächendeckende Präzisions-Upgrades stören exakt die sicheren Schritte, die übereinstimmten, und die Übereinstimmung sinkt¹.

Das getriggerte Verfahren selbst (Intervention C): native Logits berechnen; fällt der Top-Two-Margin unter τ = 10 hoch minus 3, den ganzen lm_head in FP32 neu berechnen (Gewichte und Hidden-State im Fluss hochgecastet, keine dauerhaften FP32-Kopien). Auf TinyLlama hebt das die exakte Übereinstimmung von 41 auf 63 Prozent auf GSM8K (36→61 HumanEval, 30→55 MBPP) bei unter 4 Prozent Latenz (+1,4 Prozent Latenz, +11 Prozent Spitzenspeicher; Auslöser auf 0,7 bis 1,4 Prozent der Schritte). Das getriggerte C feuert auf exakt 30 von 100 GSM8K-Prompts und konvertiert 22 — die Stratifizierung sagt den Headline-Lift ohne Tuning voraus und zögert korrekt, auf den 29 Prompts zu feuern, deren Flip von akkumuliertem Upstream-Fehler angetrieben wird, den eine Einzel-Schritt-Neuberechnung nicht versöhnen kann¹.

4. Die Anwendbarkeitskarte, und wo die Reparatur stirbt

Modellübergreifend, Batch-Größe 1 auf A10G, landet der Lift in drei Stufen: +22 Prozentpunkte TinyLlama-1.1B, +36 Llama-3.2-3B (Stufe 1); +3 Qwen2.5-3B, +8 Mistral-7B, +10 OLMoE-1B-7B (Stufe 2); 0 auf DS-R1-Distill-Qwen-7B, dessen 100 von 100 Prompts mit Median des ersten Divergenz-Schritts bei 6 divergieren — die getesteten BF16-saturierten Qwen-Varianten produzieren FP16-Body-NaNs und First-Token-Divergenz, die eine Head-scoped Reparatur nicht erreicht (Stufe 3). Das Paper hypothesiert — ausdrücklich als Hypothese —, dass die Effektivität der Trainingszeit-Präzisionsstabilität folgt, nicht der Größe¹. Auch die Hardware verschiebt die Zahlen: Auf L4 und A100 liegen die getesteten Lifte bei +12 bis +21 Prozentpunkten, wobei Qwen2.5-3B auf A10G +3, auf L4 aber +20 Punkte erreicht — die A10G ist der Ausreißer, und der Headline-Bereich ist ein Punkt in einem hardwareabhängigen Bereich.

Zwei Grenzen sind hart. Erstens der Batch: Der Fall des Lifts von +17 Prozentpunkten bei Batch 1 auf 0 bei Batch 8 rührt daher, dass Batching Reduktionsreihenfolgen ändert und effektiv eine dritte Trajektorie erzeugt statt einer größeren Lücke zwischen zweien — der gemessene Hidden-State-Abstand zwischen Batch 1 und Batch 8 (0,0127) ist statistisch ununterscheidbar von der funktionierenden BF16-vs-FP16-Konfiguration, also ist nicht die Lücke selbst das Tödliche. Das Verfahren ist in der eigenen Scope-Aussage des Papers ein Werkzeug für niedrige Batches (bis 4) und Einzel-Streams. Zweitens FP8 end-to-end: Nur den lm_head auf FP8-E4M3 zu quantisieren (Body geteilt) lässt eine neu skalierte Reparatur funktionieren — exakte Übereinstimmung auf TinyLlama, +56 Prozentpunkte auf Qwen2.5-3B bei τ = 0,25 —, aber das Quantisieren aller 155 linearen Module macht die Divergenz body-dominiert, und dieselbe Reparatur holt nur +1 Punkt zurück. Das Weiten des Gates hilft nicht. Es gibt zudem einen harten Boden, den keine Head-seitige Reparatur überqueren kann: Selbst beide Arme in FP32 erreichen nur 0,88 Übereinstimmung, wenn einer BF16-Gewichte speichert und der andere FP16-Gewichte, weil sich die gespeicherten Mantissen unterscheiden — etwa 12 Prozentpunkte irreduzible Gewichtstrunkierungs-Lücke¹. Die eigene Zusammenfassung des Papers ist die richtige: eine partielle Abschwächung, keine Determinismus-Garantie.

5. Die zweite Achse: Kernel-Wahl über Architekturen

Das erste Paper hielt die Hardware fix und variierte die Präzision. Das zweite variiert die Hardware und findet einen tieferen Kanal². Frameworks wählen GEMM-Kernel pro Architektur — cuBLAS-Heuristiken, geschlüsselt nach SM-Zahl, Kacheln, Split-K-Faktoren —, und jeder Kernel impliziert eine andere parallele Reduktionsreihenfolge, akkumuliert mit Tensor-Core-Arithmetik, deren internes Verhalten (trunkierte Signifikand-Ausrichtung, Carry-Out, Zwischenbreite) offiziell undokumentiert und über Volta, Ampere, Ada und Hopper nachweisbar unterschiedlich ist. Eine Falle lauert in der naheliegenden Lösung: „FP32"-GEMMs laufen auf modernen NVIDIA-GPUs typischerweise auf Tensor Cores in TF32, das Eingaben auf eine 10-Bit-Signifikand rundet — ein nominell FP32-Pipeline erbt also still die unspezifizierte Arithmetik, falls TF32 nicht abgeschaltet wird, und Framework-Schalter propagieren nicht in Triton-generierte Kernel².

Die State-of-the-Art-Abschwächung (LayerCast, Yuan et al., NeurIPS-2025-Oral — die Baseline des GEMM-Papers) speichert Gewichte in BF16 und castet jede Gewichtsmatrix just-in-time in eine flüchtige FP32-Kopie für die Berechnung hoch³. Sie ist wirksam, aber doppelt fehlerhaft: Der GEMM liest die FP32-Kopie, also bleibt der Gewicht-Speicherverkehr — die Größe, die Decode-Latenz setzt — auf FP32-Breite; und der Vendor-GEMM wählt weiterhin Reduktionsreihenfolgen pro Gerät, also bleibt die GPU-übergreifende Reproduzierbarkeit statistisch: Auf den Probe-Shapes des Papers war der Cast-then-cuBLAS-Pfad über A100, L40S und H100 auf keinem Shape bitweise identisch — A100 und L40S widersprachen sich auf allen sieben, mit 88 bis 99 Prozent abweichender Ausgabeelemente².

Die Lösung nagelt jeden geräteabhängigen Freiheitsgrad mit vier Designregeln fest: (R1) Jedes Skalarprodukt läuft als IEEE-754-FMA auf CUDA Cores — für gegebene Operanden bitweise spezifiziert auf jeder Architektur —, niemals auf Tensor Cores; (R2) kein Autotuning: Kernel-Konfigurationen sind Compile-Zeit-Konstanten, gewählt allein durch die Problemform (dieselbe Suche auf drei GPUs wählte nur für 3 von 9 repräsentativen Shapes dieselbe Konfiguration, und einmal auf einem Gerät wiederholt, änderte sie ihre eigene Antwort bei 1 von 9); (R3) deterministisches Split-K: Teilsummen in fixierter aufsteigender Segment-Reihenfolge kombiniert, ohne Atomics; (R4) Batch-Invarianz per Konstruktion — die K-Segmentierung hängt nur an K, nie an der Batch-Dimension, also sind die Ausgaben eines Requests bitweise unabhängig von mitgeplanter Last für Batch-Größen 1 bis 64². Gewichte laden mit 16-Bit-Breite und werden in Registern nach FP32 hochgecastet — der Gewicht-Verkehr halbiert sich.

Das Ergebnis ist Reproduzierbarkeit per Konstruktion statt per Margin: Die Reduktionsreihenfolge der linearen Schichten ist eine reine Funktion der Problemform, GPU-übergreifende Übereinstimmung reduziert sich also auf eine Prämisse — dass jede GPU IEEE-754-FP32 korrekt implementiert — und die Probe bestätigt bitweise identische lineare Ausgaben über A100, L40S und H100 auf allen sieben Shapes. End-to-end in vLLM divergiert unabschwächtes BF16 auf 30,81 bis 100 Prozent der Probleme (Median etwa 85 Prozent) über GPU-Paare; die FP32-Baseline drückt das unter 1 Prozent, lässt aber Reste bis 0,51 Prozent auf fünf von zwölf Zellen; die fixierten Kernel liegen überall auf oder unter der Baseline und sind auf elf von zwölf null — die eine verbleibende Zelle (0,08 Prozent, Qwen3-4B GSM8K) ist ein einzelnes Token an einem exakten FP32-Tie, rückverfolgbar auf einen nicht gepinnten Layer-0-Attention-Kernel auf dem H100, nicht auf die linearen Schichten. Und der Performance-Anspruch, an der Primärquelle verifiziert: end-to-end schneller als der Cast-then-GEMM-State of the Art in allen 36 Modell-Benchmark-GPU-Konfigurationen, um den Faktor 1,17–1,43 auf A100 und H100 und 1,6–3,1 auf den bandbreiten-armen L40S, plus 1–1,4 GiB Gewicht-Ersparnis, die auf Modellen mit ungetiedem Embedding in KV-Cache-Kapazität umgewandelt wird². Der Scope zählt: Der Vergleich gilt gegen FP32-Berechnungs-Abschwächung bei Batch 32, Modelle 3B–14B, einzelne GPU — nicht gegen unabschwächten BF16-Durchsatz und nicht gegen Tensor-Core-GEMMs, die dieses Design bewusst nie verwendet (sein IEEE-FMA-Triton-GEMM erreicht im Prefill etwa 0,85-fache cuBLAS-Durchsatzrate).

6. Eine Wurzel, zwei Achsen, zwei verschiedene Reparaturen

Beide Papers zusammen gelesen, wird die Struktur sauber. Die Nichtassoziativität der Fließkomma-Addition ist die unveränderliche Wurzel; die Papers unterscheiden sich darin, welcher Freiheitsgrad die Additionen ordnet. Im Präzisions-Paper sind Hardware und Kernel fix und die Formate verschieden — BF16s 7-Bit-Mantisse (maschinelles Epsilon etwa 3,9 · 10 hoch minus 3) versus FP16s 10 Bits (etwa 4,9 · 10 hoch minus 4), eine 8-fache Lücke —, also produzieren dieselben Gewichte bei jedem Schritt verschiedene Logits. Im GEMM-Paper sind die Formate fix und die Kernel-Wahl pro Gerät verschieden, also erzeugen dieselben Gewichte, dasselbe Format, dieselbe Software verschiedene Reduktionsreihenfolgen auf verschiedenen GPUs. Beide Kanäle enden im selben Ereignis: eine gerichtete Störung, die einen kleinen Top-Two-Margin an der Entscheidung übersteigt, durch die lm_head-Projektion verstärkt, durch autoregressives Konditionieren kaskadierend.

Die Reparaturen unterscheiden sich entsprechend, und keine davon ist „überall mehr Präzision". Das Präzisions-Paper repariert das Woher (nur der lm_head, nur Low-Margin-Schritte) — und zeigt, dass breiteres Reparieren schlechter ist. Das GEMM-Paper repariert das Wie der Reihenfolgen-Fixierung (die Reduktionsreihenfolge zur reinen Funktion der Problemform machen) — und zeigt, dass bloßes Schrumpfen des Rauschens auf FP32-Skala eine statistische, keine konstruierte Garantie lässt. Jede ist die ehrliche Antwort auf ihre Achse: Margin-Gating nutzt die Bimodalität, die die Margin-Verteilung mitbringt; das Pinnen der Reduktionsreihenfolge nutzt die Tatsache, dass IEEE-754-FMA für gegebene Operanden bitweise spezifiziert ist. Gemeinsam klammern sie auch die Grenzen ein: Die Head-scoped Reparatur versagt bei Batch 8 und unter FP8 end-to-end; der fixierte GEMM lässt Attention-, Normalisierungs- und Sampler-Kernel ungepinnt (der Attention-Pfad des H100 verschob Margins noch mit einem Median von 7,9 · 10 hoch minus 6 Nat, mit 9,6 Prozent bitweise gleicher Positionen gegenüber 98,4 Prozent zwischen A100 und L40S)².

7. Anti-Hype: was keines der Papers behauptet

Beide Papers sind sorgfältig mit ihrem Scope, und die Sorgfalt ist der nützliche Teil.

Größe. Die Evidenz des Präzisions-Papers läuft von 1,1B bis 7B über sechs Modelle, plus eine nur-Divergenz-Probe bei 12B (Mistral-Nemo). Der volle Interventionsvergleich ist weder bei 12B noch bei 70B+ evaluiert — das Paper sagt das in seinen Limitierungen wörtlich. Ob 400B-Klasse-Frontier-Modelle dieselbe Margin-Ereignis-Struktur zeigen oder dieselbe Erholbarkeit im Stil von +22 Prozentpunkten, ist eine Extrapolation, die das Paper nicht macht. Was per Konstruktion doch überträgt, ist der Mechanismus: die exakte Flip-Bedingung ist formatpaar-agnostisch, und das Paper zeigt dasselbe Low-Margin-Muster in Head-isoliertem FP8 und in FP16-vs-FP32.

„Mehr Präzision macht es schlechter" braucht den Vorhersage-Rahmen. Das kontraintuitive Resultat ist spezifisch das Erweitern des FP32-Umfangs jenseits des lm_head an sicheren Schritten: Vorhersage 5 der fünf prä-registrierten Vorhersagen des Papers, bestätigt als 63 → 44 Prozent auf TinyLlama (RMSNorm+lm_head) und repliziert auf DeepSeek-R1-7B bei τ = 0. Es ist keine Behauptung, FP32-Inferenz sei schlechter als BF16 — das FP32-Orakel ist 100 Prozent Übereinstimmung, und FP16 ist der bessere FP32-Proxy (FP16 allein stimmt mit FP32 auf 90 Prozent der Sequenzen überein versus 42 Prozent für BF16 auf TinyLlama). Die Lektion betrifft die Selektivität: Ungezielte neue Arithmetik an übereinstimmenden Schritten erzeugt Divergenz, die vorher nicht da war.

Die Abschwächung ist partiell, und ihre Grenzen sind der Befund. +22 bis 36 Prozentpunkte auf A10G heißen 55 bis 67 Prozent Übereinstimmung, nicht 100. Der Rest hat eine gemessene Zerlegung: Rund 12 Prozentpunkte sind der Gewichtstrunkierungs-Boden zwischen BF16 und FP16 (unterschiedlich gespeicherte Mantissen), irreduzibel ohne ein geteiltes Speicherformat; Batch-8- und FP8-end-to-end-Regime sind body-dominiert und brauchen Body-scoped Komposition; die Genauigkeit bleibt innerhalb getesteter Margins erhalten (TOST-Nicht-Unterlegenheit auf Qwen2.5-3B bei n = 600, p = 0,009), aber Mistral-7B zeigt eine unaufgeklärte −3 bis −5-Punkte-Punktschätzung, die n = 100 nicht auflösen kann. Wer bit-exakte Wiedergabe braucht, soll die vollständige numerische Konfiguration pinnen oder eine End-to-end-Referenz höherer Präzision verwenden — die eigene Empfehlung des Papers¹.

Bitweise Kernel-Determinismus gilt für die linearen Schichten. Die Garantie des GEMM-Papers deckt die GEMMs (die dominanten FLOPs und den identifizierten Divergenzkanal) — Attention, Rotary-Embeddings, Normalisierung und Sampler bleiben Vendor-Kernel mit architekturabhängigen Pfaden, und die eine überlebende End-to-end-Divergenz-Zelle liegt exakt dort. Cross-Vendor-Portabilität — wo Software sich unterscheidet, nicht nur Hardware — ist als offenes Problem benannt, und der 1,17–3,1-fache Anspruch gilt spezifisch gegenüber dem FP32-Status quo der Abschwächung, nicht gegenüber unabschwächtem BF16².

Die Einsatzfrage, auf die beide Papers hinauslaufen: Hört auf, „Greedy, Temperatur 0, Seed fixiert" als Reproduzierbarkeitsvertrag zu behandeln. Notiert die vollständige numerische Konfiguration — Formatpaar, Batch-Größe, Kernel-Wahl, Architektur — oder konstruiert die Reihenfolge der Additionen so, dass sie invariant ist. Determinismus ist keine Eigenschaft, die Greedy Decoding mitbringt; sie ist eine Eigenschaft, die man baut — entweder durch Margin-Gating oder durch das Pinnen von Reduktionsreihenfolgen — und jeder Weg kommt mit einer gemessenen Karte dessen, wo er aufhört zu funktionieren.

Fußnoten