Wer lokale KI-Modelle auf Apple Silicon betreibt, stößt unweigerlich auf das fundamentale Paradoxon moderner Inferenz: Die GPU-Rechenkerne langweilen sich, während der Speicherbus glüht.

Klassische autoregressive Large Language Models (LLMs) sind für lokale Hardware berüchtigt ineffizient. Weil jedes Token sequentiell berechnet wird, muss für jedes einzelne Wort das gesamte Modellgewicht einmal komplett aus dem Unified Memory in die GPU-ALUs gestreamt werden. Bei 512 Tokens und einem schlanken 0.5B Modell bedeutet das über 470 GB reinen RAM-Lesetransfer.

Die Kern-Frage: Kann die neue Stanford-Architektur Next-Concept Modeling (NCM) ([arXiv:2610.14162](https://arxiv.org/abs/2610.14162)) das Bottleneck von Speicherbandbreite auf reine Rechenleistung verschieben? Unsere empirische Untersuchung liefert einen ungeschminkten Systems-Befund über die Realität von Compute- vs. Memory-Bound Generation.

1. Der naive Port (Stanford Eager Path)

Stanfords Referenz-Implementation auf MPS zeigte erhebliche Mängel:

  • BPE-Falle: 1 NCM-Position ≈ 0.58 BPE-Tokens. Real nur 5.1x weniger Gewichts-Streaming (nicht nominal 8.9x).
  • 85.2 % mehr Transformer-Token-Zyklen: 512 Prefix-Tokens wurden mangels Cross-Level KV-Cache 9x redundant neu berechnet.
  • CPU-Fallback-Stalls: F.interpolate(mode='area') blockierte die Metal-Pipeline 8x pro Sample.
  • Ergebnis: +138 % Energie-Penalty (0.289 J/tok vs 0.121 J/tok), 31 % langsamer als AR.

2. Systems-Level Optimization (Co-Design)

Drei systemnahe Optimierungen in src/ncm_mps_runner.py beheben die Software-Flaschenhälse:

  • Cross-Level Prefix KV-Cache: Snapshot vor Level 0 spart 6.75x Prefix-FLOPs (100 % bit-identisch, torch.equal=True).
  • Hardware-native GPU-Matrix-Interp: Precomputed Projection Matrix input @ W ohne CPU-Transfer.
  • Single-Pass Final-Decode: 60M VQ-VAE Decoder läuft nur 1x am Ende statt 9x pro Stufe.
  • Ergebnis: 310.1 BPE tok/s (1.84x schneller als PyTorch MPS FP16) und 43.7 % weniger Energie pro Token.

1. Der Bottleneck-Shift: Memory Bandwidth → Compute

Klassische autoregressive LLMs generieren Token für Token. Bei Batch-Size 1 müssen für jedes einzelne Token die vollständigen Modellgewichte aus dem RAM in die Rechenkerne gestreamt werden (\(\mathcal{O}(T \cdot W)\)). NCM zerlegt Sequenzen über einen Multiscale Residual VQ-VAE in eine fixe Konzept-Hierarchie (9 Level bei XSum, 12 Level bei Sudoku). Pro Hierarchie-Ebene wird nur ein einziger paralleler Forward-Pass ausgeführt (\(\mathcal{O}(L \cdot W)\)).

A. Statistische Qualitätsevaluation (XSum, Großstichprobe N = 500)

Um methodische Unschärfen kleiner Stichproben auszuschließen, wurden alle Modelle im Paired Design über 500 BBC-Nachrichtenartikel aus dem XSum-Evaluationsset mit nativer Ground-Truth-Referenz getestet. Ausgewiesen sind Mittelwert ± Standardabweichung (\(\text{Mean} \pm \text{Std}\)) sowie die exakte Signifikanzprüfung via **Paired Bootstrap mit 10.000 Resamples**:

Modell / Architektur Backend / Optimierung Passes Ø BPE-Tokens Gemessene Dauer Iso-Latenz (28 Tok)* BPE Durchsatz ROUGE-1 ROUGE-2 ROUGE-L
Qwen2.5-0.5B (AR Baseline) PyTorch MPS (FP16, Zero-Shot) 48 28.1 178.4 ms 177.8 ms 157.5 tok/s 0.2227 ± 0.101 0.0462 ± 0.064 0.1678 ± 0.081
Qwen2.5-0.5B (AR MLX 4-Bit) Apple MLX (Metal, 4-Bit) 48 35.4 106.7 ms 84.3 ms 332.1 tok/s 0.2283 ± 0.088 0.0424 ± 0.054 0.1664 ± 0.069
NCM Fast (Naive Eager Port) PyTorch MPS (Eager, FP16) 9 25.9 380.0 ms 410.0 ms 68.3 tok/s 0.3442 ± 0.142 0.1292 ± 0.125 0.2759 ± 0.134
NCM Fast (Systems-Optimized) PyTorch MPS (Prefix-KV, FP16) 9 25.9 89.8 ms 96.9 ms 288.9 tok/s 0.3442 ± 0.142 0.1292 ± 0.125 0.2759 ± 0.134
Hybrid (NCM + MLX 4-Bit)* 16b MPS + 4b Metal 137 176.0 3.39 s - 51.9 tok/s 0.1824 ± 0.065 0.0448 ± 0.048 0.1308 ± 0.039
Signifikanz (NCM vs. AR Base) Paired Bootstrap (10k, N=500) - - - - - Δ = +0.121 (p < 0.0001) Δ = +0.083 (p < 0.0001) Δ = +0.108 (p < 0.0001)
Signifikanz (NCM vs. MLX 4b) Paired Bootstrap (10k, N=500) - - - - - Δ = +0.116 (p < 0.0001) Δ = +0.087 (p < 0.0001) Δ = +0.110 (p < 0.0001)

* Methodische Erläuterungen zu Tabelle 1:
1. Invariante A (\(\text{Tokens} / \text{Dauer} = \text{Durchsatz}\)): Der Durchsatz berechnet sich exakt aus \(\text{Tokens} / \text{Dauer}\) (z. B. 28.1 tok / 0.1784s = 157.5 tok/s; 35.44 tok / 0.1067s = 332.1 tok/s; 25.94 tok / 0.0898s = 288.9 tok/s).
2. Iso-Token-Normalisierung: Auf eine einheitliche Ziel-Länge von 28.0 BPE-Tokens normiert (\(28.0 / \text{Durchsatz}\)) decodiert MLX 4-Bit in nur 84.3 ms (vs. 96.9 ms für NCM Fast).
3. Stichproben-Kennzeichnung: AR Baseline, MLX 4-Bit und NCM Fast wurden über alle \(N = 500\) Samples evaluiert. Die Hybrid-Pipeline wurde aus Laufzeitgründen (3.39s/Sample) auf einem repräsentativen Subset von \(N = 20\) Samples evaluiert.
4. Steady-State vs. Burst-Durchsatz: Tabelle 1 zeigt die reale End-to-End Inferenz pro Sample über 500 diskrete Läufe. Der in Tabelle 3 für powermetrics gemessene Durchsatz (310.4 tok/s NCM, 345.1 tok/s MLX) stammt aus kontinuierlichem Hardware-Streaming im Burst-Regime.

⚠️ Wichtige methodische Einschränkung (Task-Spezialisierungs-Confounder):
Der NCM-Checkpoint von Stanford wurde gezielt auf dem XSum-Trainingsdatensatz fine-tuned. Qwen2.5-0.5B hingegen wurde im Zero-Shot-Verfahren evaluiert. Die statistisch hochsignifikanten ROUGE-Vorteile (\(p < 0,0001\)) sind daher primär ein Artefakt der aufgabenspezifischen Spezialisierung und kein Beweis für eine universelle Überlegenheit.

Bit-Identitäts-Nachweis: Ein torch.equal(g_naive, g_opt) Test über alle 20/20 XSum-Samples bestätigte 100.0 % exakte Identität (0 Mismatch-Tokens). Die maximale absolute Differenz zwischen CPU-Interpolation und MPS-GPU-Matrixmultiplikation beträgt exakt \(0.00 \times 10^0\).

B. Diskrete Symbol-Planung: Sudoku-Hard Evaluation (Symmetrisch N = 100 vs. AR Baseline)

Sudoku besitzt ein striktes, nicht-kausales Regelgitter (9 Zeilen, 9 Spalten, 9 3×3-Blöcke = 27 Constraints) ohne BPE-Tokenizer-Verzerrungen. Beide Modelle wurden auf denselben 100 Puzzles (Indices 0–99) evaluiert:

Modell / Architektur Generierungs-Methode Puzzles (\(N\)) Passes / Puzzle Dauer / Puzzle Ø Constraints (von 27) Perfekte Lösungsrate
Qwen2.5-0.5B-Instruct Autoregressiv (Zero-Shot) 100 ~95 Passes 0.469s 1.79 / 27 (± 2.1) 0 / 100 (0.0 %)
NCM Sudoku-Hard Hierarchisch (12 Levels, Task-Trained) 100 12 Passes 0.077s (1.181 pos/s) 26.39 / 27 (± 1.50) 84 / 100 (84.0 %)

Struktureller Befund: Autoregressives Left-to-Right Decoding ohne Backtracking oder Suchbäume scheitert auf globalen Constraint-Puzzles erwartbar (1.79/27 Constraints), da frühe Entscheidungen spätere Zeilen blockieren. NCMs hierarchische Multi-Scale Repräsentation schärft grobe Ziffernmuster über 12 Stufen parallel nach und löst 84 % der schweren Puzzles fehlerfrei.

C. Physische Hardware-Telemetrie am Apple Silicon SoC (powermetrics)

Kontinuierliche Abtastung der Hardware-Sensoren über powermetrics (Abtastrate 100 ms) unter Abzug der statischen System-Idle-Baseline (\(P_{\text{idle}} = 1,59\) W). Alle Werte erfüllen exakt die physikalischen Invarianten \(E_{\text{total}} = P_{\text{avg}} \times t\) und \(J/\text{tok} = E_{\text{total}} / \text{Tokens}\):

Modell / Konfiguration BPE Tokens Dauer (s) BPE Durchsatz Ø SoC Power Dyn. Power Total Energy (J) J / BPE (Total) J / BPE (Dyn)
Qwen2.5-0.5B (MLX 4-Bit Metal) 2.250 6.52s 345.1 tok/s 25.81 W 24.22 W 168.28 J 0.0748 J/tok 0.0702 J/tok
Qwen2.5-0.5B (PyTorch MPS FP16) 960 5.70s 168.4 tok/s 19.19 W 17.60 W 109.38 J 0.1139 J/tok 0.1045 J/tok
NCM Fast (Systems-Optimized) 1.679 5.41s 310.4 tok/s 19.86 W 18.27 W 107.44 J 0.0640 J/tok 0.0589 J/tok
🔬 Erkenntnisse des Iso-Token Hardware-Vergleichs:
  • Gegenüber der unoptimierten PyTorch MPS FP16 Baseline (168.4 tok/s) ist NCM Fast (310.4 tok/s) um 1.84x schneller und verbraucht 43.8 % weniger Energie pro Token (0.0640 J vs. 0.1139 J).
  • Gegenüber der optimierten Apple MLX 4-Bit Metal Baseline (345.1 tok/s) ist NCM im Durchsatz leicht langsamer (-10 %), aber 14.4 % energieeffizienter pro Token (0.0640 J vs. 0.0748 J), da MLX bei Vollast 25.81 W zieht.

D. Statistische MBR-Kandidaten-Skalierung (Ablation über \(N = 20\) Samples)

Untersuchung von Test-Time Scaling via Minimum Bayes Risk (MBR) Konsensentscheidung (\(K = 1, 4, 8\)) gemittelt über 20 repräsentative XSum-Artikel (passages[0:20]):

Kandidaten (\(K\)) Passes Dauer / Sample Effektiver BPE Durchsatz ROUGE-1 ROUGE-2 ROUGE-L MBR Utility Score*
1 (Fast) 9 0.098s 285.4 tok/s 0.3509 ± 0.144 0.1218 ± 0.119 0.2706 ± 0.137 -
4 (Low Effort) 36 0.454s 61.6 tok/s 0.3452 ± 0.154 0.1197 ± 0.115 0.2613 ± 0.147 0.4292
8 (Medium Effort) 72 0.897s 31.2 tok/s 0.3466 ± 0.150 0.1205 ± 0.129 0.2686 ± 0.138 0.4339

* Methodik & Befund: Kandidat #0 wird stets deterministisch als Greedy-Anker (\(T=0,7\), top_k=1, top_p=0) generiert, während ab \(k \ge 1\) eine Temperaturspreizung (\(T=0,85 \dots 1,15\)) den Konzeptraum exploriert. Auf Text-Summarization bringt MBR-Konsens keine statistisch signifikante ROUGE-Verbesserung, während der \(4,6\times\) bis \(9,2\times\) höhere Rechenaufwand den effektiven Durchsatz auf 31,2 tok/s drückt.

2. Das Roofline-Modell: Wo NCM bei 14B+ skaliert (und wo nicht)

Ein oft geäußertes Missverständnis ist, NCM würde bei 14B-Modellen und 1.024 Tokens die Inferenzzeit auf „~1 Sekunde“ drücken, weil nur 145.6 GB Gewichte gestreamt werden. Das ist physikalisch falsch. Eine vollständige Roofline-Analyse (Speicherbandbreite vs. Rechenleistung) offenbart die wahre Natur des Bottleneck-Shifts:

Metrik (14B Modell, 1.024 Tokens, 273 GB/s Bus) Autoregressives LLM (14B 4-Bit) Next-Concept Modeling (14B, 16 Level)
Vorwärtsdurchläufe (Passes) 1.024 sequentielle Schritte 16 hierarchische Schritte
Modellgewichts-Transfer 9.318,4 GB (9,32 TB) 145,6 GB (64x Ersparnis!)
Speicher-Streaming-Zeit (\(t_{\text{mem}} = \text{GB} / 273\)) 34,13 Sekunden 0,53 Sekunden
Gesamte Matrix-FLOPs (\(W_{\text{FLOPs}}\)) 28,7 TFLOPs (1 Token/Pass) 229,4 TFLOPs (alle Tokens parallel)
Reine Rechenzeit (\(t_{\text{compute}} = \text{FLOPs} / 15 \text{ TFLOPs}\)) 1,91 Sekunden 15,29 – 30,6 Sekunden
Physikalische Latenz \(\max(t_{\text{mem}}, t_{\text{compute}})\) 34,13 Sekunden 15,29 – 30,6 Sekunden
Dominanter Engpass 95 % Memory-Bound (DRAM-Stall) 98 % Compute-Bound (ALU-Saturation)
Realer Wanduhrzeit-Speedup Baseline (1.0x) 1.1x bis 2.2x (nicht 64x!)
Das wissenschaftliche Fazit des Roofline-Modells:
NCM spart bei 1.024 Tokens tatsächlich 9.172,8 GB RAM-Streaming ein. Weil NCM aber auf allen Hierarchie-Ebenen die gesamte Sequenz parallel berechnen muss, explodiert der Rechenaufwand von 28.7 auf 229+ TFLOPs.
Der Bottleneck-Shift findet real statt (die GPU wartet nicht mehr auf RAM, sondern rechnet unter Volllast). Die Latenz sinkt jedoch moderat um 1.1x bis 2.2x (von 34s auf 15–30s) – keineswegs um den Faktor 64x.

3. Das 2-Stufen Hybrid-System: Ein empirisches Negativergebnis

Die vorgestellte 2-Stufen-Hybrid-Pipeline (NCM MPS + MLX Metal 4-Bit) erweist sich in der Praxis als klares Negativergebnis:

4. Open Source & Exakte Reproduktionsumgebung

Das vollständige, lauffähige Proof of Concept inklusive aller Systems-Optimierungen (Cross-Level Prefix KV-Cache, GPU-Matrix-Interpolation), powermetrics Profiling und XSum-Evaluierungsskripten steht Open Source auf GitHub bereit:

Zum GitHub Repository: PiinoStudio/ncm-apple-silicon ↗

Dokumentierte Testumgebung:
• System: macOS Sequoia (Darwin 26B118, Apple Silicon MacBook Pro M5 Pro, 24 GB Unified Memory, 273 GB/s Bandbreite)
• Software-Stack: Python 3.11.11, PyTorch 2.4.0 (MPS), Apple MLX 0.22.0, Transformers 4.48.0, Rouge-Score 0.1.2
• Datensätze: XSum (\(N = 500\) Samples), Sudoku-Hard (\(N = 100\) Puzzles)